+ * Provides base test initialization and runtime + * logic into a common class. + * All test areas will need to extend this class + * to provided area specific functionality needed for + * that particular technology. + *+ */ +@ExtendWith({ArquillianExtension.class}) +public abstract class BaseUrlClient { + + protected final Logger logger = LoggerFactory.getLogger(getClass()); + + @ArquillianResource @OperateOnDeployment("_DEFAULT_") + public URL url; + + /** + * Properties parameters + */ + public Properties _props; + + /** + * 401 - Unauthorized + */ + protected static final String UNAUTHORIZED = "401"; + + /** + * 403 - Forbidden + */ + protected static final String FORBIDDEN = "403"; + + /** + * 404 - not found + */ + protected static final String NOT_FOUND = "404"; + + /** + * 200 - ok + */ + protected static final String OK = "200"; + + /** + * 201 - created + */ + protected static final String CREATED = "201"; + + /** + * 500 - internal server error + */ + protected static final String INTERNAL_SERVER_ERROR = "500"; + + /** + * 503 - service unavailable + */ + protected static final String SERVICE_UNAVAILABLE = "503"; + + /** + * 100 - continue + */ + protected static final String CONTINUE = "100"; + + /** + * 302 - moved temporarily + */ + protected static final String MOVED_TEMPORARY = "302"; + + /** + * 410 - GONE + */ + protected static final String GONE = "410"; + + /** + * 411 - length required + */ + protected static final String LENGTH_REQUIRED = "411"; + + /** + * TS Webserver host property + */ + protected static final String SERVLETHOSTPROP = "webServerHost"; + + /** + * TS Webserver port property + */ + protected static final String SERVLETPORTPROP = "webServerPort"; + + /** + * TS home property + */ + protected static final String TSHOME = "ts_home"; + + /** + * Test properties + */ + protected static final Properties TEST_PROPS = new Properties(); + + /** + * StatusCode property + */ + protected static final String STATUS_CODE = "status-code"; + + /** + * Reason-Phrase property + */ + protected static final String REASON_PHRASE = "reason-phrase"; + + /** + * Expected headers property + */ + protected static final String EXPECTED_HEADERS = "expected_headers"; + + /** + * Unexpected header property + */ + protected static final String UNEXPECTED_HEADERS = "unexpected_headers"; + + /** + * Expect response body property + */ + protected static final String EXPECT_RESPONSE_BODY = "expect_response_body"; + + /** + * Request property + */ + protected static final String REQUEST = "request"; + + /** + * Request headers property + */ + protected static final String REQUEST_HEADERS = "request_headers"; + + /** + * Search string property + */ + protected static final String SEARCH_STRING = "search_string"; + + /** + * Search string case insensitive property + */ + protected static final String SEARCH_STRING_IGNORE_CASE = "search_string_ignore_case"; + + /** + * Basic Auth username + */ + protected static final String BASIC_AUTH_USER = "basic_auth_user"; + + /** + * Basic Auth password + */ + protected static final String BASIC_AUTH_PASSWD = "basic_auth_passwd"; + + /** + * Basic Auth realm + */ + protected static final String BASIC_AUTH_REALM = "basic_auth_realm"; + + protected static final String UNAUTH_USERNAME = "authuser"; + + protected static final String UNAUTH_PASSWORD = "authpassword"; + + + // Constants: + protected static final String USERNAME = "user"; + + protected static final String PASSWORD = "password"; + + /** + * Unordered search string property + */ + protected static final String UNORDERED_SEARCH_STRING = "unordered_search_string"; + + /** + * Content property + */ + protected static final String CONTENT = "content"; + + /** + * Test name property + */ + protected static final String TEST_NAME = "testname"; + + /** + * Response Match property + */ + protected static final String RESPONSE_MATCH = "response_match"; + + /** + * Unexpected response match property + */ + protected static final String UNEXPECTED_RESPONSE_MATCH = "unexpected_response_match"; + + /** + * Standard test property + */ + protected static final String STANDARD = "standard"; + + /** + * Ignore response body + */ + protected static final String IGNORE_BODY = "ignore_body"; + + /** + * Validation strategy + */ + protected static final String STRATEGY = "strategy"; + + /** + * Current test directory + */ + protected String TESTDIR = null; + + /** + * Goldenfile directory + */ + protected String GOLDENFILEDIR = "/src/web"; + + /** + * Default request method + */ + protected static final String GET = "GET "; + + /** + * HTTP 1.0 + */ + protected static final String HTTP10 = " HTTP/1.0"; + + /** + * HTTP 1.1 + */ + protected static final String HTTP11 = " HTTP/1.1"; + + /** + * Forward slash + */ + protected static final String SL = "/"; + + /** + * Goldenfile suffix + */ + protected static final String GF_SUFFIX = ".gf"; + + /** + * JSP suffix + */ + protected static final String JSP_SUFFIX = ".jsp"; + + /** + * Use any saved state + */ + protected static final String USE_SAVED_STATE = "use_saved_state"; + + /** + * Save current HTTP state. + */ + protected static final String SAVE_STATE = "save_state"; + + /** + * Ignore HTTP status codes + */ + protected static final String IGNORE_STATUS_CODE = "ignore_status_code"; + + /** + * Current test name + */ + protected String _testName = null; + + /** + * location of _tsHome + */ + protected String _tsHome = null; + + /** + * Context root of target tests + */ + protected String _contextRoot = null; + + /** + * General file/request URI for both gfiles and tests + */ + protected String _generalURI = null; + + /** + * Target webserver hostname + */ + protected String _hostname = null; + + /** + * Target webserver port + */ + protected int _port = 0; + + /** + * HttpState that may be used for multiple invocations requiring state. + */ + protected HttpState _state = null; + + /** + * Test case. + */ + protected WebTestCase _testCase = null; + + /** + * Use saved state. + */ + protected boolean _useSavedState = false; + + /** + * Save state. + */ + protected boolean _saveState = false; + + /** + * Follow redirect. + */ + protected static final String FOLLOW_REDIRECT = "follow_redirect"; + + protected boolean _redirect = false; + + /* + * public methods + * ======================================================================== + */ + + /** + *
setTestDir sets the current test directory.
+ *
+ * @param testDir
+ * a String value
+ */
+ public void setTestDir(String testDir) {
+ TESTDIR = testDir;
+ // setGoldenFileDir(testDir);
+ }
+
+ public void setGeneralURI(String URI) {
+ _generalURI = URI;
+ }
+
+ public void setContextRoot(String root) {
+ _contextRoot = root;
+ }
+
+ public String getContextRoot() {
+ return _contextRoot;
+ }
+
+ /**
+ * Sets the goldenfile directory
+ *
+ * @param goldenDir
+ * goldenfile directory based off test directory
+ */
+ public void setGoldenFileDir(String goldenDir) {
+ GOLDENFILEDIR = goldenDir;
+ }
+
+ @BeforeEach
+ public void setup() throws Exception {
+ String ctxRoot = url.getPath();
+ setContextRoot(ctxRoot.endsWith("/")?ctxRoot.substring(0, ctxRoot.length()-1):ctxRoot);
+ Properties properties = new Properties();
+ properties.put(SERVLETHOSTPROP, url.getHost());
+ properties.put(SERVLETPORTPROP, Integer.toString(url.getPort()));
+ // TODO do we really need this??
+ properties.put(TSHOME, Paths.get("target/test-classes").toFile().getName());
+ // TOFIX configuration
+ properties.setProperty("servlet_waittime", System.getProperty("servlet_waittime","10"));
+ properties.setProperty("servlet_async_wait", System.getProperty("servlet_async_wait","4"));
+ properties.setProperty("logical.hostname.servlet", System.getProperty("logical.hostname.servlet","server"));
+ properties.setProperty(USERNAME, System.getProperty(USERNAME, "j2ee"));
+ properties.setProperty(PASSWORD, System.getProperty(PASSWORD, "j2ee"));
+ properties.setProperty(BASIC_AUTH_PASSWD, System.getProperty(UNAUTH_PASSWORD, "j2ee"));
+ properties.setProperty(BASIC_AUTH_USER, System.getProperty(BASIC_AUTH_USER, "j2ee"));
+ properties.setProperty(BASIC_AUTH_PASSWD, System.getProperty(UNAUTH_PASSWORD, "j2ee"));
+ properties.setProperty(UNAUTH_USERNAME, System.getProperty(UNAUTH_USERNAME, "javajoe"));
+ properties.setProperty(UNAUTH_PASSWORD, System.getProperty(UNAUTH_PASSWORD, "javajoe"));
+ setup(null, properties);
+ }
+
+
+ /**
+ * setup is by the test harness to initialize the tests.
+ *
+ * @param args
+ * a String[] value
+ * @param p
+ * a Properties value
+ */
+ public void setup(String[] args, Properties p) throws Exception {
+ _props = p;
+ String hostname = p.getProperty(SERVLETHOSTPROP).trim();
+ String portnum = p.getProperty(SERVLETPORTPROP).trim();
+ String tshome = p.getProperty(TSHOME).trim();
+
+ if (!isNullOrEmpty(hostname)) {
+ _hostname = hostname;
+ } else {
+ throw new IllegalArgumentException(
+ "[BaseUrlClient] 'webServerHost' was not set in the" + " ts.jte.");
+ }
+
+ if (!isNullOrEmpty(portnum)) {
+ _port = Integer.parseInt(portnum);
+ } else {
+ throw new IllegalArgumentException(
+ "[BaseUrlClient] 'webServerPort' was not set in the" + " ts.jte.");
+ }
+
+ if (!isNullOrEmpty(tshome)) {
+ _tsHome = tshome;
+ } else {
+ throw new IllegalArgumentException(
+ "[BaseUrlClient] 'tshome' was not set in the " + " ts.jte.");
+ }
+
+ logger.debug("[BaseUrlClient] Test setup OK using properties {}", p);
+ }
+
+ /**
+ * cleanup is called by the test harness to cleanup after text
+ * execution
+ *
+ */
+ public void cleanup() throws Exception {
+ logger.info("[BaseUrlClient] Test cleanup OK");
+ }
+
+ /*
+ * protected methods
+ * ========================================================================
+ */
+
+ /**
+ * + * Invokes a test based on the properties + * stored in TEST_PROPS. Once the test has completed, + * the properties in TEST_PROPS will be cleared. + *+ * + */ + protected void invoke() { + try { + _testCase = new WebTestCase(); + setTestProperties(_testCase); + logger.trace("[BaseUrlClient] EXECUTING"); + if (_useSavedState && _state != null) { + _testCase.getRequest().setState(_state); + } + if (_redirect) { + logger.trace("##########Call setFollowRedirects"); + _testCase.getRequest().setFollowRedirects(_redirect); + } + _testCase.execute(); + if (_saveState) { + _state = _testCase.getResponse().getState(); + } + } catch (Exception tfe) { + Throwable t = tfe.getCause(); + if (t != null) { + logger.warn("Root cause of Failure: " + t.getMessage(), t); + } + logger.error("Test: '" + _testName + "' failed.", tfe); + throw new RuntimeException("[BaseUrlClient] " + _testName + " failed! Check output for cause of failure.", tfe); + } finally { + _useSavedState = false; + _saveState = false; + _redirect = false; + clearTestProperties(); + } + } + + /** + *
+ * Sets the appropriate test properties based + * on the values stored in TEST_PROPS + *+ */ + protected void setTestProperties(WebTestCase testCase) { + HttpRequest req = testCase.getRequest(); + + // Check for a request object. If doesn't exist, then + // check for a REQUEST property and create the request object. + + if (req == null) { + String request = TEST_PROPS.getProperty(REQUEST); + + if (request.startsWith("GET") || request.startsWith("POST") + || request.startsWith("OPTIONS") || request.startsWith("PUT") + || request.startsWith("DELETE") || request.startsWith("HEAD") + || request.endsWith(HTTP10) || request.endsWith(HTTP11)) { + // user has overriden default request behavior + req = new HttpRequest(request, _hostname, _port); + testCase.setRequest(req); + } else { + req = new HttpRequest(getTSRequest(request), _hostname, _port); + testCase.setRequest(req); + } + } + + String key = null; + String value = null; + // process the remainder of the properties + for (Enumeration e = TEST_PROPS.propertyNames(); e.hasMoreElements();) { + key = (String) e.nextElement(); + value = TEST_PROPS.getProperty(key); + + switch (key) { + case TEST_NAME: + testCase.setName(value); + _testName = value; + break; + case STATUS_CODE: + testCase.setExpectedStatusCode(value); + break; + case IGNORE_STATUS_CODE: + testCase.setExpectedStatusCode("-1"); + break; + case REASON_PHRASE: + testCase.setExpectedReasonPhrase(value); + break; + case EXPECTED_HEADERS: + testCase.addExpectedHeader(value); + break; + case UNEXPECTED_HEADERS: + testCase.addUnexpectedHeader(value); + break; + case SEARCH_STRING: + testCase.setResponseSearchString(value); + break; + case SEARCH_STRING_IGNORE_CASE: + testCase.setResponseSearchStringIgnoreCase(value); + break; + case STRATEGY: + testCase.setStrategy(value); + break; + case CONTENT: + req.setContent(value); + break; + case RESPONSE_MATCH: + // setResponseMatch(TEST_PROPS.getProperty(key)); + break; + case REQUEST_HEADERS: + req.addRequestHeader(TEST_PROPS.getProperty(key)); + break; + case EXPECT_RESPONSE_BODY: + // FIXME + // setExpectResponseBody(false); + break; + case UNEXPECTED_RESPONSE_MATCH: + testCase.setUnexpectedResponseSearchString(value); + break; + case UNORDERED_SEARCH_STRING: + testCase.setUnorderedSearchString(value); + break; + case USE_SAVED_STATE: + _useSavedState = true; + break; + case SAVE_STATE: + _saveState = true; + break; + case FOLLOW_REDIRECT: + logger.debug("##########Found redirect Property"); + _redirect = true; + break; + case BASIC_AUTH_USER: + case BASIC_AUTH_PASSWD: + case BASIC_AUTH_REALM: + String user = TEST_PROPS.getProperty(BASIC_AUTH_USER); + String password = TEST_PROPS.getProperty(BASIC_AUTH_PASSWD); + String realm = TEST_PROPS.getProperty(BASIC_AUTH_REALM); + req.setAuthenticationCredentials(user, password, HttpRequest.BASIC_AUTHENTICATION, realm); + break; + default: + // no op + } + + } + } + + /* + * private methods + * ======================================================================== + */ + + private String getTSRequest(String request) { + StringBuilder finReq = new StringBuilder(50); + + finReq.append(GET).append(_contextRoot).append(SL).append(_generalURI); + finReq.append(SL).append(request).append(HTTP10); + + return finReq.toString(); + } + + /** + * Clears the contents of TEST_PROPS + */ + private void clearTestProperties() { + TEST_PROPS.clear(); + } + + private boolean isNullOrEmpty(String val) { + return val == null || val.equals(""); + } + + public void logErr(String message) { + logger.error(message); + } + + public void logErr(String message, Exception e) { + logger.error(message, e); + } + + public void logMsg(String message) { + logger.info(message); + } + + public void logTrace(String message) { + logger.trace(message); + } + +} diff --git a/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/client/handler/ALLOWHandler.java b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/client/handler/ALLOWHandler.java new file mode 100644 index 0000000000..56c9fc5e7e --- /dev/null +++ b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/client/handler/ALLOWHandler.java @@ -0,0 +1,64 @@ +/* + * Copyright (c) 2008, 2020 Oracle and/or its affiliates. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v. 2.0, which is available at + * http://www.eclipse.org/legal/epl-2.0. + * + * This Source Code may also be made available under the following Secondary + * Licenses when the conditions for such availability set forth in the + * Eclipse Public License v. 2.0 are satisfied: GNU General Public License, + * version 2 with the GNU Classpath Exception, which is available at + * https://www.gnu.org/software/classpath/license.html. + * + * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 + */ + +/* + * $Id$ + */ +package com.sun.ts.tests.servlet.common.client.handler; + +import com.sun.ts.lib.util.TestUtil; +import org.apache.commons.httpclient.Header; + +import java.util.StringTokenizer; + +public class ALLOWHandler implements Handler { + + private static final Handler HANDLER = new ALLOWHandler(); + + private static final String DELIM = "##"; + + private ALLOWHandler() { + } + + public static Handler getInstance() { + return HANDLER; + } + + public boolean invoke(Header configuredHeader, Header responseHeader) { + String ALLOWHeader = responseHeader.getValue().toLowerCase(); + String expectedValues = configuredHeader.getValue().toLowerCase() + .replace(" ", ""); + + TestUtil.logTrace("[ALLOWHandler] ALLOW header received: " + ALLOWHeader); + + StringTokenizer conf = new StringTokenizer(expectedValues, ","); + while (conf.hasMoreTokens()) { + String token = conf.nextToken(); + String token1 = token; + + if ((ALLOWHeader.indexOf(token) < 0) + && (ALLOWHeader.indexOf(token1) < 0)) { + TestUtil.logErr("[ALLOWHandler] Unable to find '" + token + + "' within the ALLOW header returned by the server."); + return false; + } else { + TestUtil.logTrace("[ALLOWHandler] Found expected value, '" + token + + "' in ALLOW header returned by server."); + } + } + return true; + } +} diff --git a/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/client/handler/ContentTypeHandler.java b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/client/handler/ContentTypeHandler.java new file mode 100644 index 0000000000..77992bf5a8 --- /dev/null +++ b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/client/handler/ContentTypeHandler.java @@ -0,0 +1,152 @@ +/* + * The Apache Software License, Version 1.1 + * + * Copyright (c) 2007, 2020 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2000 The Apache Software Foundation. All rights + * Copyright (c) 2000 The Apache Software Foundation. All rights + * reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * 3. The end-user documentation included with the redistribution, + * if any, must include the following acknowledgment: + * "This product includes software developed by the + * Apache Software Foundation (http://www.apache.org/)." + * Alternately, this acknowledgment may appear in the software itself, + * if and wherever such third-party acknowledgments normally appear. + * + * 4. The names "Apache" and "Apache Software Foundation" must + * not be used to endorse or promote products derived from this + * software without prior written permission. For written + * permission, please contact apache@apache.org. + * + * 5. Products derived from this software may not be called "Apache", + * nor may "Apache" appear in their name, without prior written + * permission of the Apache Software Foundation. + * + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR + * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * ==================================================================== + * + * This software consists of voluntary contributions made by many + * individuals on behalf of the Apache Software Foundation. For more + * information on the Apache Software Foundation, please see + *
+ * When invoked, the content-type header + * will be appropriately handled. It allows + * flexible checking of control values against + * the response which could be in the form of: + * content-type; charset + * -or- + * conent-type + *+ */ +public class ContentTypeHandler implements Handler { + + private static Handler handler = new ContentTypeHandler(); + + /** + * Creates new ContentTypeHandler + */ + private ContentTypeHandler() { + } + + /* + * public methods + * ======================================================================== + */ + + /** + * Returns an instance of this handler. + */ + public static Handler getInstance() { + return handler; + } + + /** + * Invokes handler logic. + * + * @param configuredHeader + * the user configured header + * @param responseHeader + * the response header from the server + * @return True if the passed match, otherwise false + */ + public boolean invoke(Header configuredHeader, Header responseHeader) { + boolean ret = false; + TestUtil.logTrace("[ContentTypeHandler] ContentTypeHandler invoked."); + String configVal = configuredHeader.getValue().trim(); + String responseVal = responseHeader.getValue().trim(); + int colIdx = configVal.indexOf(';'); + if (colIdx < 0) { + // Info we're interested in : type/subtype + + // check response Content-Type header to see what format + // it's in. + int rColIdx = responseVal.indexOf(';'); + if (rColIdx < 0) { + // Type and subtype, i.e. type/subtype are to be compared + // case insensitively. + if (configVal.equalsIgnoreCase(responseVal)) { + ret = true; + } + } else { + if (configVal.equalsIgnoreCase(responseVal.substring(0, rColIdx))) { + ret = true; + } + } + } else { + // Info we're interested in : type/subtype; parameter=value + + int rColIdx = responseVal.indexOf(';'); + if (rColIdx > -1) { + String confTypeSubType = configVal.substring(0, colIdx).trim(); + String responseTypeSubType = responseVal.substring(0, rColIdx).trim(); + String confParameter = configVal.substring(colIdx + 1).trim(); + String responseParameter = (responseVal.substring(rColIdx + 1).trim()) + .replaceAll(" ", ""); + // compare type/subtype in a case insensitive manner + if (confTypeSubType.equalsIgnoreCase(responseTypeSubType)) { + // next validate the parameter in a case insensitive manner + if (confParameter.equalsIgnoreCase(responseParameter)) { + ret = true; + } + } + } + } + return ret; + } +} diff --git a/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/client/handler/DefaultHandler.java b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/client/handler/DefaultHandler.java new file mode 100644 index 0000000000..aa4ba97320 --- /dev/null +++ b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/client/handler/DefaultHandler.java @@ -0,0 +1,144 @@ +/* + * The Apache Software License, Version 1.1 + * + * Copyright (c) 2007, 2020 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2000 The Apache Software Foundation. All rights + * Copyright (c) 2000 The Apache Software Foundation. All rights + * reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * 3. The end-user documentation included with the redistribution, + * if any, must include the following acknowledgment: + * "This product includes software developed by the + * Apache Software Foundation (http://www.apache.org/)." + * Alternately, this acknowledgment may appear in the software itself, + * if and wherever such third-party acknowledgments normally appear. + * + * 4. The names "Apache" and "Apache Software Foundation" must + * not be used to endorse or promote products derived from this + * software without prior written permission. For written + * permission, please contact apache@apache.org. + * + * 5. Products derived from this software may not be called "Apache", + * nor may "Apache" appear in their name, without prior written + * permission of the Apache Software Foundation. + * + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR + * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * ==================================================================== + * + * This software consists of voluntary contributions made by many + * individuals on behalf of the Apache Software Foundation. For more + * information on the Apache Software Foundation, please see + *
+ * The default handler will handle any + * header that doesn't have a configured handler. + *+ */ +public class DefaultHandler implements Handler { + + private static Handler handler = new DefaultHandler(); + + /** + * Creates new DefaultHandler + */ + private DefaultHandler() { + } + + /* + * public methods + * ======================================================================== + */ + + /** + * Returns an instance of this handler. + */ + public static Handler getInstance() { + return handler; + } + + /** + * Invokes handler logic. + * + * @param configuredHeader + * the user configured header + * @param responseHeader + * the response header from the server + * @return True if the passed match, otherwise false + */ + public boolean invoke(Header configuredHeader, Header responseHeader) { + + TestUtil.logTrace("[DefaulHandler] DefaultHandler invoked."); + + return areHeadersEqual(configuredHeader, responseHeader); + } + + /** + * Utility method to determine equality of two Header objects + * + * @param h1 + * first header + * @param h2 + * second header + * @return true if the headers are equal, otherwise false + */ + protected boolean areHeadersEqual(Header h1, Header h2) { + + HeaderElement[] h1Values = h1.getElements(); + HeaderElement[] h2Values = h2.getElements(); + + if (h1Values.length == h2Values.length) { + for (HeaderElement h1Value : h1Values) { + String h1Val = h1Value.getName(); + boolean found = false; + for (HeaderElement h2Value : h2Values) { + if (h1Val.equals(h2Value.getName())) { + found = true; + break; + } + } + if (!found) { + return false; + } + } + return true; + } else { + return false; + } + } +} diff --git a/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/client/handler/Handler.java b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/client/handler/Handler.java new file mode 100644 index 0000000000..405811e8e4 --- /dev/null +++ b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/client/handler/Handler.java @@ -0,0 +1,84 @@ +/* ==================================================================== + * The Apache Software License, Version 1.1 + * + * Copyright (c) 2007, 2018 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2000 The Apache Software Foundation. All rights + * reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * 3. The end-user documentation included with the redistribution, + * if any, must include the following acknowledgment: + * "This product includes software developed by the + * Apache Software Foundation (http://www.apache.org/)." + * Alternately, this acknowledgment may appear in the software itself, + * if and wherever such third-party acknowledgments normally appear. + * + * 4. The names "Apache" and "Apache Software Foundation" must + * not be used to endorse or promote products derived from this + * software without prior written permission. For written + * permission, please contact apache@apache.org. + * + * 5. Products derived from this software may not be called "Apache", + * nor may "Apache" appear in their name, without prior written + * permission of the Apache Software Foundation. + * + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR + * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * ==================================================================== + * + * This software consists of voluntary contributions made by many + * individuals on behalf of the Apache Software Foundation. For more + * information on the Apache Software Foundation, please see + *
+ * The HandlerManager is responsible for returning the appropriate handler
+ * instance based on the provided value.
+ */
+public class HandlerFactory {
+
+ /**
+ * Content-Type handler name.
+ */
+ private static final String CONTENT_TYPE = "content-type";
+
+ /**
+ * Location handler name.
+ */
+ private static final String LOCATION = "location";
+
+ /**
+ * Set-Cookie handler name.
+ */
+ private static final String SET_COOKIE = "set-cookie";
+
+ /**
+ * ALLOW handler name.
+ */
+ private static final String ALLOW = "allow";
+
+ /**
+ * www-authenticate handler name.
+ */
+ private static final String WWW_AUTH = "www-authenticate";
+ /*
+ * public methods
+ * ========================================================================
+ */
+
+ /**
+ * Constructs a new HandlerManager instance
+ */
+ private HandlerFactory() {
+ }
+
+ /**
+ * Returns the appropriate handler instance based on provided discriminate (a
+ * header name).
+ *
+ * @param handlerName
+ * handler instance to obtain.
+ */
+ public static Handler getHandler(String handlerName) {
+ if (CONTENT_TYPE.equals(handlerName.toLowerCase())) {
+ return ContentTypeHandler.getInstance();
+ } else if (LOCATION.equals(handlerName.toLowerCase())) {
+ return LocationHandler.getInstance();
+ } else if (SET_COOKIE.equals(handlerName.toLowerCase())) {
+ return SetCookieHandler.getInstance();
+ } else if (WWW_AUTH.equals(handlerName.toLowerCase())) {
+ return WWWAuthenticateHandler.getInstance();
+ } else if (ALLOW.equals(handlerName.toLowerCase())) {
+ return ALLOWHandler.getInstance();
+ } else {
+ return DefaultHandler.getInstance();
+ }
+ }
+}
diff --git a/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/client/handler/LocationHandler.java b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/client/handler/LocationHandler.java
new file mode 100644
index 0000000000..da08e344c8
--- /dev/null
+++ b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/client/handler/LocationHandler.java
@@ -0,0 +1,161 @@
+/*
+ * The Apache Software License, Version 1.1
+ *
+ * Copyright (c) 2007, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000 The Apache Software Foundation. All rights
+ * Copyright (c) 2000 The Apache Software Foundation. All rights
+ * reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * 3. The end-user documentation included with the redistribution,
+ * if any, must include the following acknowledgment:
+ * "This product includes software developed by the
+ * Apache Software Foundation (http://www.apache.org/)."
+ * Alternately, this acknowledgment may appear in the software itself,
+ * if and wherever such third-party acknowledgments normally appear.
+ *
+ * 4. The names "Apache" and "Apache Software Foundation" must
+ * not be used to endorse or promote products derived from this
+ * software without prior written permission. For written
+ * permission, please contact apache@apache.org.
+ *
+ * 5. Products derived from this software may not be called "Apache",
+ * nor may "Apache" appear in their name, without prior written
+ * permission of the Apache Software Foundation.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This software consists of voluntary contributions made by many
+ * individuals on behalf of the Apache Software Foundation. For more
+ * information on the Apache Software Foundation, please see
+ *
+ * Will handle headers for the following
+ * cases:
+ * - Server is on port 80 and port value isn't
+ * propagated back to client (assumed)
+ * - Port value is in response
+ *
+ */
+public class LocationHandler implements Handler {
+
+ private static Handler handler = new LocationHandler();
+
+ /**
+ * Creates new ContentTypeHandler
+ */
+ private LocationHandler() {
+ }
+
+ /*
+ * public methods
+ * ========================================================================
+ */
+
+ /**
+ * Returns an instance of this handler.
+ */
+ public static Handler getInstance() {
+ return handler;
+ }
+
+ /**
+ * Invokes handler logic.
+ *
+ * @param configuredHeader
+ * the user configured header
+ * @param responseHeader
+ * the response header from the server
+ * @return True if the passed match, otherwise false
+ */
+ public boolean invoke(Header configuredHeader, Header responseHeader) {
+
+ boolean pass = true;
+
+ try {
+ TestUtil.logTrace("[LocationHandler] LocationHandler invoked.");
+
+ URL configURL = new URL(configuredHeader.getValue());
+ URL responseURL = new URL(responseHeader.getValue());
+
+ if (!(configURL.getProtocol().equals(responseURL.getProtocol()))) {
+ pass = false;
+ TestUtil.logErr("[LocationHandler] Mismatch between protocols:");
+ TestUtil.logErr(
+ "[LocationHandler] Configured value: " + configURL.getProtocol());
+ TestUtil.logErr(
+ "[LocationHandler] Response value: " + responseURL.getProtocol());
+ }
+
+ if (!(configURL.getPath().equals(responseURL.getPath()))) {
+ pass = false;
+ TestUtil.logErr("[LocationHandler] Mismatch between paths:");
+ TestUtil.logErr(
+ "[LocationHandler] Configured value: " + configURL.getPath());
+ TestUtil.logErr(
+ "[LocationHandler] Response value: " + responseURL.getPath());
+ }
+
+ if (configURL.getQuery() == null) {
+ if (responseURL.getQuery() != null) {
+ pass = false;
+ TestUtil.logErr("[LocationHandler] Mismatch between querys:");
+ TestUtil.logErr("[LocationHandler] Configured value is null");
+ TestUtil.logErr("[LocationHandler] Response value is non-null");
+ }
+ } else if (!(configURL.getQuery().equals(responseURL.getQuery()))) {
+ pass = false;
+ TestUtil.logErr("[LocationHandler] Mismatch between querys:");
+ TestUtil.logErr(
+ "[LocationHandler] Configured value: " + configURL.getQuery());
+ TestUtil.logErr(
+ "[LocationHandler] Response value: " + responseURL.getQuery());
+ }
+
+ } catch (MalformedURLException mue) {
+ pass = false;
+ TestUtil.logErr("[LocationHandler] MalformedURLException");
+ TestUtil.printStackTrace(mue);
+ }
+
+ return pass;
+ }
+}
diff --git a/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/client/handler/SetCookieHandler.java b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/client/handler/SetCookieHandler.java
new file mode 100644
index 0000000000..72136ecb9a
--- /dev/null
+++ b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/client/handler/SetCookieHandler.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2007, 2020 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/*
+ * $Id$
+ */
+
+package com.sun.ts.tests.servlet.common.client.handler;
+
+import com.sun.ts.lib.util.TestUtil;
+import org.apache.commons.httpclient.Header;
+
+import java.util.StringTokenizer;
+
+public class SetCookieHandler implements Handler {
+
+ private static final Handler HANDLER = new SetCookieHandler();
+
+ private static final String DELIM = "##";
+
+ private SetCookieHandler() {
+ }
+
+ public static Handler getInstance() {
+ return HANDLER;
+ }
+
+ public boolean invoke(Header configuredHeader, Header responseHeader) {
+ String setCookieHeader = responseHeader.getValue().toLowerCase();
+ String expectedValues = configuredHeader.getValue().toLowerCase();
+
+ TestUtil.logTrace(
+ "[SetCookieHandler] Set-Cookie header received: " + setCookieHeader);
+
+ StringTokenizer conf = new StringTokenizer(expectedValues, DELIM);
+ while (conf.hasMoreTokens()) {
+ String token = conf.nextToken();
+ String token1 = token;
+
+ if (token.endsWith("\"") && (token.indexOf("=\"") > 1)) {
+ token1 = token.replace("=\"", "=");
+ token1 = token1.substring(0, token.length() - 2);
+ }
+
+ if (token.startsWith("!")) {
+ String attr = token.substring(1);
+ String attr1 = token1.substring(1);
+ if ((setCookieHeader.indexOf(attr) > -1)
+ || (setCookieHeader.indexOf(attr1) > -1)) {
+ TestUtil.logErr("[SetCookieHandler] Unexpected attribute found "
+ + " Set-Cookie header. Attribute: " + attr
+ + "\nSet-Cookie header: " + setCookieHeader);
+ return false;
+ }
+ } else {
+ if ((setCookieHeader.indexOf(token) < 0)
+ && (setCookieHeader.indexOf(token1) < 0)) {
+ TestUtil.logErr("[SetCookieHandler] Unable to find '" + token
+ + "' within the Set-Cookie header returned by the server.");
+ return false;
+ } else {
+ TestUtil.logTrace("[SetCookieHandler] Found expected value, '" + token
+ + "' in Set-Cookie header returned by server.");
+ }
+ }
+ }
+
+ return true;
+ }
+}
diff --git a/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/client/handler/WWWAuthenticateHandler.java b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/client/handler/WWWAuthenticateHandler.java
new file mode 100644
index 0000000000..ab2b8a50d3
--- /dev/null
+++ b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/client/handler/WWWAuthenticateHandler.java
@@ -0,0 +1,112 @@
+/*
+ * The Apache Software License, Version 1.1
+ *
+ * Copyright (c) 2007, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000 The Apache Software Foundation. All rights
+ * Copyright (c) 2000 The Apache Software Foundation. All rights
+ * reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * 3. The end-user documentation included with the redistribution,
+ * if any, must include the following acknowledgment:
+ * "This product includes software developed by the
+ * Apache Software Foundation (http://www.apache.org/)."
+ * Alternately, this acknowledgment may appear in the software itself,
+ * if and wherever such third-party acknowledgments normally appear.
+ *
+ * 4. The names "Apache" and "Apache Software Foundation" must
+ * not be used to endorse or promote products derived from this
+ * software without prior written permission. For written
+ * permission, please contact apache@apache.org.
+ *
+ * 5. Products derived from this software may not be called "Apache",
+ * nor may "Apache" appear in their name, without prior written
+ * permission of the Apache Software Foundation.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This software consists of voluntary contributions made by many
+ * individuals on behalf of the Apache Software Foundation. For more
+ * information on the Apache Software Foundation, please see
+ *
+ * Will handle headers for the following
+ * cases:
+ * - Server is on port 80 and port value isn't
+ * propagated back to client (assumed)
+ * - Port value is in response
+ *
+ */
+public class WWWAuthenticateHandler implements Handler {
+
+ private static Handler handler = new WWWAuthenticateHandler();
+
+ /**
+ * Creates new ContentTypeHandler
+ */
+ private WWWAuthenticateHandler() {
+ }
+
+ /*
+ * public methods
+ * ========================================================================
+ */
+
+ /**
+ * Returns an instance of this handler.
+ */
+ public static Handler getInstance() {
+ return handler;
+ }
+
+ /**
+ * Invokes handler logic.
+ *
+ * @param configuredHeader
+ * the user configured header
+ * @param responseHeader
+ * the response header from the server
+ * @return True if the passed match, otherwise false
+ */
+ public boolean invoke(Header configuredHeader, Header responseHeader) {
+
+ TestUtil
+ .logTrace("[WWWAuthenticateHandler] WWAuthenticateHandler invoked.");
+ return true;
+ }
+}
diff --git a/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/HttpRequest.java b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/HttpRequest.java
new file mode 100644
index 0000000000..e59e7f092d
--- /dev/null
+++ b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/HttpRequest.java
@@ -0,0 +1,581 @@
+/*
+ * Copyright (c) 2007, 2020 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/*
+ * $Id$
+ */
+
+package com.sun.ts.tests.servlet.common.request;
+
+import org.apache.commons.httpclient.Cookie;
+import org.apache.commons.httpclient.Header;
+import org.apache.commons.httpclient.HttpClient;
+import org.apache.commons.httpclient.HttpConnection;
+import org.apache.commons.httpclient.HttpException;
+import org.apache.commons.httpclient.HttpMethod;
+import org.apache.commons.httpclient.HttpState;
+import org.apache.commons.httpclient.UsernamePasswordCredentials;
+import org.apache.commons.httpclient.auth.AuthScope;
+import org.apache.commons.httpclient.cookie.CookiePolicy;
+import org.apache.commons.httpclient.methods.EntityEnclosingMethod;
+import org.apache.commons.httpclient.methods.StringRequestEntity;
+import org.apache.commons.httpclient.protocol.DefaultProtocolSocketFactory;
+import org.apache.commons.httpclient.protocol.Protocol;
+import org.apache.commons.httpclient.protocol.ProtocolSocketFactory;
+import org.apache.commons.httpclient.protocol.SSLProtocolSocketFactory;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.Base64;
+import java.util.StringTokenizer;
+
+/**
+ * Represents an HTTP client Request
+ */
+
+public class HttpRequest {
+
+
+// static {
+// if (TestUtil.traceflag) {
+// System.setProperty("org.apache.commons.logging.Log",
+// "com.sun.ts.tests.common.webclient.log.WebLog");
+// System.setProperty(
+// "org.apache.commons.logging.simplelog.log.httpclient.wire", "debug");
+// }
+// }
+
+ private static final Logger LOGGER = LoggerFactory.getLogger(HttpRequest.class);
+
+ /**
+ * Default HTTP port.
+ */
+ public static int DEFAULT_HTTP_PORT = 80;
+
+ /**
+ * Default HTTP SSL port.
+ */
+ public static final int DEFAULT_SSL_PORT = 443;
+
+ /**
+ * No authentication
+ */
+ public static final int NO_AUTHENTICATION = 0;
+
+ /**
+ * Basic authentication
+ */
+ public static final int BASIC_AUTHENTICATION = 1;
+
+ /**
+ * Digest authenctication
+ */
+ public static final int DIGEST_AUTHENTICATION = 2;
+
+ /**
+ * Method representation of request.
+ */
+ private HttpMethod _method = null;
+
+ /**
+ * Target web container host
+ */
+ private String _host = null;
+
+ /**
+ * Target web container port
+ */
+ private int _port = DEFAULT_HTTP_PORT;
+
+ /**
+ * Is the request going over SSL
+ */
+ private boolean _isSecure = false;
+
+ /**
+ * HTTP state
+ */
+ private HttpState _state = null;
+
+ /**
+ * Original request line for this request.
+ */
+ private String _requestLine = null;
+
+ /**
+ * Authentication type for current request
+ */
+ private int _authType = NO_AUTHENTICATION;
+
+ /**
+ * Flag to determine if session tracking will be used or not.
+ */
+ private boolean _useCookies = false;
+
+ /**
+ * Content length of request body.
+ */
+ private int _contentLength = 0;
+
+ /**
+ * FollowRedirects
+ */
+ private boolean _redirect = false;
+
+ Header[] _headers = null;
+
+ protected HttpClient client = null;
+
+ /**
+ * Creates new HttpRequest based of the passed request line. The request line
+ * provied must be in the form of:
+ *
+ *
+ * METHOD PATH HTTP-VERSION
+ * Ex. GET /index.html HTTP/1.0
+ *
+ */
+ public HttpRequest(String requestLine, String host, int port) {
+ client = new HttpClient();
+ _method = MethodFactory.getInstance(requestLine);
+ _method.setFollowRedirects(false);
+ _host = host;
+ _port = port;
+
+ if (port == DEFAULT_SSL_PORT) {
+ _isSecure = true;
+ }
+
+ // If we got this far, the request line is in the proper
+ // format
+ _requestLine = requestLine;
+ }
+
+ /*
+ * public methods
+ * ========================================================================
+ */
+
+ /**
+ * getRequestPath returns the request path for this particular
+ * request.
+ *
+ * @return String request path
+ */
+ public String getRequestPath() {
+ return _method.getPath();
+ }
+
+ /**
+ * getRequestMethod returns the request type, i.e., GET, POST,
+ * etc.
+ *
+ * @return String request type
+ */
+ public String getRequestMethod() {
+ return _method.getName();
+ }
+
+ /**
+ * isSecureConnection() indicates if the Request is secure or
+ * not.
+ *
+ * @return boolean whether Request is using SSL or not.
+ */
+ public boolean isSecureRequest() {
+ return _isSecure;
+ }
+
+ /**
+ * setSecureRequest configures this request to use SSL.
+ *
+ * @param secure
+ * - whether the Request uses SSL or not.
+ */
+ public void setSecureRequest(boolean secure) {
+ _isSecure = secure;
+ }
+
+ /**
+ * setContent will set the body for this request. Note, this is
+ * only valid for POST and PUT operations, however, if called and the request
+ * represents some other HTTP method, it will be no-op'd.
+ *
+ * @param content
+ * request content
+ */
+ public void setContent(String content) {
+ if (_method instanceof EntityEnclosingMethod) {
+ ((EntityEnclosingMethod) _method)
+ .setRequestEntity(new StringRequestEntity(content));
+ }
+ _contentLength = content.length();
+ }
+
+ /**
+ * setAuthenticationCredentials configures the request to
+ * perform authentication.
+ *
+ * username and password cannot be null.
+ *
+ *
+ *
+ * It is legal for realm to be null.
+ *
+ *
+ * @param username
+ * the user
+ * @param password
+ * the user's password
+ * @param authType
+ * authentication type
+ * @param realm
+ * authentication realm
+ */
+ public void setAuthenticationCredentials(String username, String password,
+ int authType, String realm) {
+ if (username == null) {
+ throw new IllegalArgumentException("Username cannot be null");
+ }
+
+ if (password == null) {
+ throw new IllegalArgumentException("Password cannot be null");
+ }
+
+ UsernamePasswordCredentials cred = new UsernamePasswordCredentials(username,
+ password);
+ AuthScope scope = new AuthScope(_host, _port, realm);
+ getState().setCredentials(scope, cred);
+
+ LOGGER.debug("Added credentials for '{}' with password '{}' in realm '{}'", username, password, realm);
+
+ _authType = authType;
+ }
+
+ /**
+ * addRequestHeader adds a request header to this request. If a
+ * request header of the same name already exists, the new value, will be
+ * added to the set of already existing values.
+ *
+ * NOTE: that header names are not case-sensitive.
+ *
+ * @param headerName
+ * request header name
+ * @param headerValue
+ * request header value
+ */
+ public void addRequestHeader(String headerName, String headerValue) {
+ _method.addRequestHeader(headerName, headerValue);
+ LOGGER.debug("Added request header: {}", _method.getRequestHeader(headerName).toExternalForm());
+ }
+
+ public void addRequestHeader(String header) {
+ StringTokenizer st = new StringTokenizer(header, "|");
+ while (st.hasMoreTokens()) {
+ String h = st.nextToken();
+ if (h.toLowerCase().startsWith("cookie")) {
+ createCookie(h);
+ continue;
+ }
+ int col = h.indexOf(':');
+ addRequestHeader(h.substring(0, col).trim(), h.substring(col + 1).trim());
+ }
+ }
+
+ /**
+ * setRequestHeader sets a request header for this request
+ * overwritting any previously existing header/values with the same name.
+ *
+ * NOTE: Header names are not case-sensitive.
+ *
+ * @param headerName
+ * request header name
+ * @param headerValue
+ * request header value
+ */
+ public void setRequestHeader(String headerName, String headerValue) {
+ _method.setRequestHeader(headerName, headerValue);
+ LOGGER.trace("Set request header: {}", _method.getRequestHeader(headerName).toExternalForm());
+
+ }
+
+ /**
+ * setFollowRedirects indicates whether HTTP redirects are
+ * followed. By default, redirects are not followed.
+ */
+ public void setFollowRedirects(boolean followRedirects) {
+ _method.setFollowRedirects(followRedirects);
+ }
+
+ /**
+ * getFollowRedirects indicates whether HTTP redirects are
+ * followed.
+ */
+ public boolean getFollowRedirects() {
+ return _method.getFollowRedirects();
+ }
+
+ /**
+ * setState will set the HTTP state for the current request (i.e.
+ * session tracking). This has the side affect
+ */
+ public void setState(HttpState state) {
+ _state = state;
+ _useCookies = true;
+ }
+
+ /**
+ * execute will dispatch the current request to the target
+ * server.
+ *
+ * @return HttpResponse the server's response.
+ * @throws IOException
+ * if an I/O error occurs during dispatch.
+ */
+ public HttpResponse execute() throws IOException, HttpException {
+ String method;
+ int defaultPort;
+ ProtocolSocketFactory factory;
+
+ if (_method.getFollowRedirects()) {
+ client = new HttpClient();
+
+ if (_isSecure) {
+ method = "https";
+ defaultPort = DEFAULT_SSL_PORT;
+ factory = new SSLProtocolSocketFactory();
+ } else {
+ method = "http";
+ defaultPort = DEFAULT_HTTP_PORT;
+ factory = new DefaultProtocolSocketFactory();
+ }
+
+ Protocol protocol = new Protocol(method, factory, defaultPort);
+ HttpConnection conn = new HttpConnection(_host, _port, protocol);
+
+ if (conn.isOpen()) {
+ throw new IllegalStateException("Connection incorrectly opened");
+ }
+
+ conn.open();
+
+ LOGGER.info("[HttpRequest] Dispatching request: '{}' to target server at '{}:{}'", _requestLine , _host, _port);
+
+ addSupportHeaders();
+ _headers = _method.getRequestHeaders();
+
+ LOGGER.debug(
+ "########## The real value set: {}", _method.getFollowRedirects());
+
+ client.getHostConfiguration().setHost(_host, _port, protocol);
+
+ client.executeMethod(_method);
+
+ return new HttpResponse(_host, _port, _isSecure, _method, getState());
+ } else {
+ if (_isSecure) {
+ method = "https";
+ defaultPort = DEFAULT_SSL_PORT;
+ factory = new SSLProtocolSocketFactory();
+ } else {
+ method = "http";
+ defaultPort = DEFAULT_HTTP_PORT;
+ factory = new DefaultProtocolSocketFactory();
+ }
+
+ Protocol protocol = new Protocol(method, factory, defaultPort);
+ HttpConnection conn = new HttpConnection(_host, _port, protocol);
+
+ if (conn.isOpen()) {
+ throw new IllegalStateException("Connection incorrectly opened");
+ }
+
+ conn.open();
+
+ LOGGER.info("Dispatching request: '{}' to target server at '{}:{}'", _requestLine, _host, _port);
+
+ addSupportHeaders();
+ _headers = _method.getRequestHeaders();
+
+ LOGGER.debug("########## The real value set: {}", _method.getFollowRedirects());
+
+ _method.execute(getState(), conn);
+
+ return new HttpResponse(_host, _port, _isSecure, _method, getState());
+ }
+ }
+
+ /**
+ * Returns the current state for this request.
+ *
+ * @return HttpState current state
+ */
+ public HttpState getState() {
+ if (_state == null) {
+ _state = new HttpState();
+ }
+ return _state;
+ }
+
+ public String toString() {
+ StringBuilder sb = new StringBuilder(255);
+ sb.append("[REQUEST LINE] -> ").append(_requestLine).append('\n');
+
+ if (_headers != null && _headers.length != 0) {
+
+ for (Header _header : _headers) {
+ sb.append("[REQUEST HEADER] -> ");
+ sb.append(_header.toExternalForm()).append('\n');
+ }
+ }
+
+ if (_contentLength != 0) {
+ sb.append("[REQUEST BODY LENGTH] -> ").append(_contentLength);
+ sb.append('\n');
+ }
+
+ return sb.toString();
+
+ }
+
+ /*
+ * private methods
+ * ========================================================================
+ */
+
+ private void createCookie(String cookieHeader) {
+ String cookieLine = cookieHeader.substring(cookieHeader.indexOf(':') + 1)
+ .trim();
+ StringTokenizer st = new StringTokenizer(cookieLine, " ;");
+ Cookie cookie = new Cookie();
+ cookie.setVersion(1);
+
+ getState();
+
+ if (cookieLine.indexOf("$Version") == -1) {
+ cookie.setVersion(0);
+ _method.getParams().setCookiePolicy(CookiePolicy.NETSCAPE);
+ }
+
+ while (st.hasMoreTokens()) {
+ String token = st.nextToken();
+
+ if (token.charAt(0) != '$' && !token.startsWith("Domain")
+ && !token.startsWith("Path")) {
+ cookie.setName(token.substring(0, token.indexOf('=')));
+ cookie.setValue(token.substring(token.indexOf('=') + 1));
+ } else if (token.indexOf("Domain") > -1) {
+ cookie.setDomainAttributeSpecified(true);
+ cookie.setDomain(token.substring(token.indexOf('=') + 1));
+ } else if (token.indexOf("Path") > -1) {
+ cookie.setPathAttributeSpecified(true);
+ cookie.setPath(token.substring(token.indexOf('=') + 1));
+ }
+ }
+ _state.addCookie(cookie);
+
+ }
+
+ /**
+ * Adds any support request headers necessary for this request. These headers
+ * will be added based on the state of the request.
+ */
+ private void addSupportHeaders() {
+
+ // Authentication headers
+ // NOTE: Possibly move logic to generic method
+ switch (_authType) {
+ case NO_AUTHENTICATION:
+ break;
+ case BASIC_AUTHENTICATION:
+ setBasicAuthorizationHeader();
+ break;
+ case DIGEST_AUTHENTICATION:
+ throw new UnsupportedOperationException("Digest Authentication is not currently " + "supported");
+ }
+
+ // A Host header will be added to each request to handle
+ // cases where virtual hosts are used, or there is no DNS
+ // available on the system where the container is running.
+ setHostHeader();
+
+ // Content length header
+ setContentLengthHeader();
+
+ // Cookies
+ setCookieHeader();
+ }
+
+ /**
+ * Sets a basic authentication header in the request is Request is configured
+ * to use basic authentication
+ */
+ private void setBasicAuthorizationHeader() {
+ UsernamePasswordCredentials cred = (UsernamePasswordCredentials) getState()
+ .getCredentials(new AuthScope(_host, _port, null));
+ String authString = null;
+ if (cred != null) {
+ authString = "Basic " + new String(Base64.getEncoder().encode((cred.getUserName() + ":" + cred.getPassword()).getBytes()));
+ } else {
+ LOGGER.trace("[HttpRequest] NULL CREDENTIALS");
+ }
+ _method.setRequestHeader("Authorization", authString);
+ }
+
+ /**
+ * Sets a Content-Length header in the request if content is present
+ */
+ private void setContentLengthHeader() {
+ if (_contentLength > 0) {
+ _method.setRequestHeader("Content-Length", Integer.toString(_contentLength));
+ }
+ }
+
+ /**
+ * Sets a host header in the request. If the configured host value is an IP
+ * address, the Host header will be sent, but without any value.
+ *
+ * If we adhered to the HTTP/1.1 spec, the Host header must be empty of the
+ * target server is identified via IP address. However, no user agents I've
+ * tested follow this. And if a custom client library does this, it may not
+ * work properly with the target server. For now, the Host request-header will
+ * always have a value.
+ */
+ private void setHostHeader() {
+ if (_port == DEFAULT_HTTP_PORT || _port == DEFAULT_SSL_PORT) {
+ _method.setRequestHeader("Host", _host);
+ } else {
+ _method.setRequestHeader("Host", _host + ":" + _port);
+ }
+ }
+
+ /**
+ * Sets a Cookie header if this request is using cookies.
+ */
+ private void setCookieHeader() {
+ if (_useCookies) {
+ Cookie[] cookies = _state.getCookies();
+ if (cookies != null && cookies.length > 0) {
+ Header cHeader = CookiePolicy.getCookieSpec(CookiePolicy.RFC_2109)
+ .formatCookieHeader(_state.getCookies());
+ if (cHeader != null) {
+ _method.setRequestHeader(cHeader);
+ }
+ }
+ }
+ }
+}
diff --git a/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/HttpRequestClient.java b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/HttpRequestClient.java
new file mode 100644
index 0000000000..e43ee28066
--- /dev/null
+++ b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/HttpRequestClient.java
@@ -0,0 +1,391 @@
+/*
+ * Copyright (c) 2007, 2020 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/*
+ * $Id$
+ */
+
+package com.sun.ts.tests.servlet.common.request;
+
+import com.sun.ts.tests.servlet.common.util.Data;
+
+public class HttpRequestClient extends RequestClient {
+
+
+ public void getAuthTypeWithoutProtectionTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getAuthTypeWithoutProtectionTest");
+ invoke();
+ }
+
+
+ public void getAuthTypeTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getAuthTypeTest");
+ invoke();
+ }
+
+
+ public void getContextPathTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getContextPathTest");
+ TEST_PROPS.setProperty(REQUEST_HEADERS, "result:" + getContextRoot());
+ invoke();
+ }
+
+
+ public void getCookiesTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getCookiesTest");
+ TEST_PROPS.setProperty(REQUEST_HEADERS,
+ "Cookie: cookie=value; Domain=" + _hostname + "; Path=/");
+ invoke();
+ }
+
+
+ public void getCookiesNoCookiesTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getCookiesNoCookiesTest");
+ invoke();
+ }
+
+
+ public void getDateHeaderTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getDateHeaderTest");
+ TEST_PROPS.setProperty(REQUEST_HEADERS,
+ "If-Modified-Since:Sat, 01 Jan 2000 00:00:01 GMT");
+ invoke();
+ }
+
+
+ public void getDateHeaderNoHeaderTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getDateHeaderNoHeaderTest");
+ invoke();
+ }
+
+
+ public void getDateHeaderIllegalArgumentExceptionTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST,
+ "getDateHeaderIllegalArgumentExceptionTest");
+ TEST_PROPS.setProperty(REQUEST_HEADERS, "If-Modified-Since:java");
+ invoke();
+ }
+
+
+ public void getHeaderTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getHeaderTest");
+ TEST_PROPS.setProperty(REQUEST_HEADERS, "User-Agent: Mozilla/4.0");
+ invoke();
+ }
+
+
+ public void getHeaderNoHeaderTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getHeaderNoHeaderTest");
+ invoke();
+ }
+
+
+ public void getHeaderNamesTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getHeaderNamesTest");
+ TEST_PROPS.setProperty(REQUEST_HEADERS,
+ "If-Modified-Since:Sat, 01 Jan 2000 00:00:01 GMT|Cookie:cookie=value");
+ invoke();
+ }
+
+
+ public void getHeaderNamesNoHeaderTest() throws Exception {
+ String testName = "getHeaderNamesNoHeaderTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST, "GET " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(SEARCH_STRING, Data.PASSED);
+ invoke();
+ }
+
+
+ public void getHeadersTest() throws Exception {
+ String testName = "getHeadersTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST, "GET " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(REQUEST_HEADERS, "Accept-Language:en-us, ga-us");
+ TEST_PROPS.setProperty(SEARCH_STRING, Data.PASSED);
+ invoke();
+
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST, "GET " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(REQUEST_HEADERS,
+ "Accept-Language:en-us|Accept-Language:ga-us");
+ TEST_PROPS.setProperty(SEARCH_STRING, Data.PASSED);
+ invoke();
+
+ }
+
+
+ public void getHeadersNoHeadersTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getHeadersNoHeadersTest");
+ invoke();
+ }
+
+
+ public void getIntHeaderTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getIntHeaderTest");
+ TEST_PROPS.setProperty(REQUEST_HEADERS, "MyIntHeader:123");
+ invoke();
+ }
+
+
+ public void getIntHeaderNumberFoundExceptionTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getIntHeaderNumberFoundExceptionTest");
+ TEST_PROPS.setProperty(REQUEST_HEADERS, "MyNonIntHeader:Java");
+ invoke();
+ }
+
+
+ public void getIntHeaderNoHeaderTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getIntHeaderNoHeaderTest");
+ invoke();
+ }
+
+
+ public void getMethodTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getMethod_GETTest");
+ invoke();
+ String testName = "getMethod_POSTTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST, "POST " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + " HTTP/1.1");
+ invoke();
+ testName = "getMethod_HEADTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST, "HEAD " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(EXPECTED_HEADERS, "status:" + Data.PASSED);
+ TEST_PROPS.setProperty(IGNORE_BODY, "true");
+ invoke();
+ }
+
+
+ public void getPathInfoTest() throws Exception {
+ String testName = "getPathInfoTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST,
+ "GET " + getContextRoot() + "/" + getServletName()
+ + "/pathinfostring1/pathinfostring2?testname=" + testName
+ + " HTTP/1.1");
+ invoke();
+ }
+
+
+ public void getPathInfoNullTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getPathInfoNullTest");
+ invoke();
+ }
+
+
+ public void getPathTranslatedTest() throws Exception {
+ String testName = "getPathTranslatedTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST,
+ "GET " + getContextRoot() + "/" + getServletName()
+ + "/jakarta_servlet?testname=" + testName + " HTTP/1.1");
+ invoke();
+ }
+
+
+ public void getPathTranslatedNullTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getPathTranslatedNullTest");
+ invoke();
+ }
+
+
+ public void getQueryStringTest() throws Exception {
+ String testName = "getQueryStringTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST, "GET " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + "&qs=value1 HTTP/1.1");
+ invoke();
+ }
+
+
+ public void getQueryStringNullTest() throws Exception {
+ String testName = "getQueryStringNullTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST,
+ "GET " + getContextRoot() + "/" + testName + " HTTP/1.1");
+ invoke();
+ }
+
+
+ public void getRequestedSessionIdNullTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getRequestedSessionIdNullTest");
+ invoke();
+ }
+
+
+ public void getRequestedSessionIdTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getSessionTrueNoSessionTest");
+ TEST_PROPS.setProperty(SAVE_STATE, "true");
+ invoke();
+ TEST_PROPS.setProperty(APITEST, "invalidateSessionId");
+ TEST_PROPS.setProperty(SAVE_STATE, "true");
+ TEST_PROPS.setProperty(USE_SAVED_STATE, "true");
+ invoke();
+ TEST_PROPS.setProperty(APITEST, "getRequestedSessionIdTest");
+ TEST_PROPS.setProperty(SAVE_STATE, "true");
+ TEST_PROPS.setProperty(USE_SAVED_STATE, "true");
+ invoke();
+ }
+
+
+ public void getRequestedSessionIdTest1() throws Exception {
+ String testName = "getRequestedSessionIdTest1";
+ TEST_PROPS.setProperty(REQUEST,
+ "GET " + getContextRoot() + "/" + getServletName()
+ + ";jsessionid=c0o7fszeb1" + "?testname=" + testName
+ + "&TCKidsetto=c0o7fszeb1 HTTP/1.1");
+ TEST_PROPS.setProperty(SEARCH_STRING,
+ "Test returned with RequestdSessionId=c0o7fszeb1");
+ invoke();
+ }
+
+
+ public void getRequestedSessionIdTest2() throws Exception {
+ String testName = "getRequestedSessionIdTest2";
+ TEST_PROPS.setProperty(REQUEST,
+ "GET " + getContextRoot() + "/" + getServletName()
+ + ";jsessionid=xyzc0o7fszeb1" + "?testname=" + testName
+ + "&TCKidsetto=xyzc0o7fszeb1 HTTP/1.1");
+ TEST_PROPS.setProperty(SEARCH_STRING,
+ "Test returned with RequestdSessionId=xyzc0o7fszeb1");
+ invoke();
+ }
+
+
+ public void getRemoteUserTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getRemoteUserTest");
+ invoke();
+ }
+
+
+ public void getRequestURITest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getRequestURITest");
+ TEST_PROPS.setProperty(REQUEST_HEADERS, "result:" + getContextRoot());
+ invoke();
+ }
+
+
+ public void getServletPathTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getServletPathTest");
+ invoke();
+ }
+
+
+ public void getServletPathEmptyStringTest() throws Exception {
+ String testName = "getServletPathEmptyStringTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST,
+ "GET " + getContextRoot() + "/" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(SEARCH_STRING, Data.PASSED);
+ invoke();
+ }
+
+
+ public void isRequestedSessionIdFromCookieTest() throws Exception {
+ String testName = "isRequestedSessionIdFromCookieTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST, "GET " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(SEARCH_STRING, "Actual result = false");
+ invoke();
+ }
+
+
+ public void isRequestedSessionIdFromCookieTest1() throws Exception {
+
+ TEST_PROPS.setProperty(APITEST, "getSessionTest");
+ TEST_PROPS.setProperty(SAVE_STATE, "true");
+ TEST_PROPS.setProperty(USE_SAVED_STATE, "true");
+ invoke();
+
+ String testName = "isRequestedSessionIdFromCookieTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST, "GET " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(SEARCH_STRING, "Actual result = true");
+ TEST_PROPS.setProperty(USE_SAVED_STATE, "true");
+ TEST_PROPS.setProperty(SAVE_STATE, "true");
+ invoke();
+ }
+
+
+ public void isRequestedSessionIdFromURLTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "isRequestedSessionIdFromURLTest");
+ invoke();
+ }
+
+
+ public void isRequestedSessionIdValidTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "isRequestedSessionIdValidTest");
+ invoke();
+ }
+
+
+ public void getSessionTrueTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getSessionTrueNoSessionTest");
+ TEST_PROPS.setProperty(SAVE_STATE, "true");
+ invoke();
+ TEST_PROPS.setProperty(APITEST, "getSessionTrueSessionTest");
+ TEST_PROPS.setProperty(USE_SAVED_STATE, "true");
+ invoke();
+ }
+
+
+ public void getSessionFalseTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getSessionFalseTest");
+ invoke();
+ }
+
+
+ public void getSessionTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getSessionTest");
+ invoke();
+ }
+
+
+ public void getRequestURLTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getRequestURLTest");
+ TEST_PROPS.setProperty(REQUEST_HEADERS,
+ "scheme:http|server:" + _hostname + "|port:" + _port + "|servletpath:"
+ + "-" + getContextRoot().substring(1, getContextRoot().length())
+ + "-" + getServletName());
+ invoke();
+ }
+
+
+ public void sessionTimeoutTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "sessionTimeoutTest");
+ invoke();
+ }
+
+
+ public void changeSessionIDTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "changeSessionIDTest");
+ invoke();
+ }
+
+
+ public void changeSessionIDTest1() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "changeSessionIDTest1");
+ invoke();
+ }
+}
diff --git a/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/HttpResponse.java b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/HttpResponse.java
new file mode 100644
index 0000000000..345935e8e9
--- /dev/null
+++ b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/HttpResponse.java
@@ -0,0 +1,330 @@
+/*
+ * Copyright (c) 2006, 2020 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/*
+ * $Id$
+ */
+
+package com.sun.ts.tests.servlet.common.request;
+
+import org.apache.commons.httpclient.Header;
+import org.apache.commons.httpclient.HttpMethod;
+import org.apache.commons.httpclient.HttpMethodBase;
+import org.apache.commons.httpclient.HttpState;
+import org.apache.commons.httpclient.HttpVersion;
+
+import java.io.BufferedReader;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * This class represents an HTTP response from the server.
+ */
+
+public class HttpResponse {
+
+ /**
+ * Default encoding based on Servlet Specification
+ */
+ private static final String DEFAULT_ENCODING = "ISO-8859-1";
+
+ /**
+ * Content-Type header
+ */
+ private static final String CONTENT_TYPE = "Content-Type";
+
+ /**
+ * Wrapped HttpMethod used to pull response info from.
+ */
+ private HttpMethod _method = null;
+
+ /**
+ * HttpState obtained after execution of request
+ */
+ private HttpState _state = null;
+
+ /**
+ * Charset encoding returned in the response
+ */
+ private String _encoding = DEFAULT_ENCODING;
+
+ /**
+ * The response body. Initialized after first call to one of the
+ * getResponseBody methods and cached for subsequent calls.
+ */
+ private String _responseBody = null;
+
+ /**
+ * Host name used for processing request
+ */
+ private String _host = null;
+
+ /**
+ * Port number used for processing request
+ */
+ private int _port;
+
+ /**
+ * Issecure
+ */
+ private boolean _isSecure;
+
+ /** Creates new HttpResponse */
+ public HttpResponse(String host, int port, boolean isSecure,
+ HttpMethod method, HttpState state) {
+
+ _host = host;
+ _port = port;
+ _isSecure = isSecure;
+ _method = method;
+ _state = state;
+ }
+
+ /*
+ * public methods
+ * ========================================================================
+ */
+
+ /**
+ * Returns the HTTP status code returned by the server
+ *
+ * @return HTTP status code
+ */
+ public String getStatusCode() {
+ return Integer.toString(_method.getStatusCode());
+ }
+
+ /**
+ * Returns the HTTP reason-phrase returned by the server
+ *
+ * @return HTTP reason-phrase
+ */
+ public String getReasonPhrase() {
+ return _method.getStatusText();
+ }
+
+ /**
+ * Returns the headers received in the response from the server.
+ *
+ * @return response headers
+ */
+ public Header[] getResponseHeaders() {
+ return _method.getResponseHeaders();
+ }
+
+ public List getHeaders() {
+ return Arrays.asList(_method.getResponseHeaders());
+ }
+
+ /**
+ * Returns the headers designated by the name provided.
+ *
+ * @return response headers
+ */
+ public Header[] getResponseHeaders(String headerName) {
+ return _method.getResponseHeaders(headerName);
+ }
+
+ /**
+ * Returns the response header designated by the name provided.
+ *
+ * @return a specfic response header or null if the specified header doesn't
+ * exist.
+ */
+ public Header getResponseHeader(String headerName) {
+ return _method.getResponseHeader(headerName);
+ }
+
+ /**
+ * Returns the response body as a byte array using the charset specified in
+ * the server's response.
+ *
+ * @return response body as an array of bytes.
+ */
+ public byte[] getResponseBodyAsBytes() throws IOException {
+ return getEncodedResponse().getBytes();
+ }
+
+ /**
+ * Returns the response as bytes (no encoding is performed by client.
+ *
+ * @return the raw response bytes
+ * @throws IOException
+ * if an error occurs reading from server
+ */
+ public byte[] getResponseBodyAsRawBytes() throws IOException {
+ return _method.getResponseBody();
+ }
+
+ /**
+ * Returns the response body as a string using the charset specified in the
+ * server's response.
+ *
+ * @return response body as a String
+ */
+ public String getResponseBodyAsString() throws IOException {
+ return getEncodedResponse();
+ }
+
+ /**
+ * Returns the response body of the server without being encoding by the
+ * client.
+ *
+ * @return an unecoded String representation of the response
+ * @throws IOException
+ * if an error occurs reading from the server
+ */
+ public String getResponseBodyAsRawString() throws IOException {
+ return _method.getResponseBodyAsString();
+ }
+
+ /**
+ * Returns the response body as an InputStream using the encoding specified in
+ * the server's response.
+ *
+ * @return response body as an InputStream
+ */
+ public InputStream getResponseBodyAsStream() throws IOException {
+ return new ByteArrayInputStream(getEncodedResponse().getBytes());
+ }
+
+ /**
+ * Returns the response body as an InputStream without any encoding applied by
+ * the client.
+ *
+ * @return an InputStream to read the response
+ * @throws IOException
+ * if an error occurs reading from the server
+ */
+ public InputStream getResponseBodyAsRawStream() throws IOException {
+ return _method.getResponseBodyAsStream();
+ }
+
+ /**
+ * Returns the charset encoding for this response.
+ *
+ * @return charset encoding
+ */
+ public String getResponseEncoding() {
+ Header content = _method.getResponseHeader(CONTENT_TYPE);
+ if (content != null) {
+ String headerVal = content.getValue();
+ int idx = headerVal.indexOf(";charset=");
+ if (idx > -1) {
+ // content encoding included in response
+ _encoding = headerVal.substring(idx + 9);
+ }
+ }
+ return _encoding;
+ }
+
+ /**
+ * Returns the post-request state.
+ *
+ * @return an HttpState object
+ */
+ public HttpState getState() {
+ return _state;
+ }
+
+ /**
+ * Displays a String representation of the response.
+ *
+ * @return string representation of response
+ */
+ public String toString() {
+ StringBuffer sb = new StringBuffer(255);
+
+ sb.append("[RESPONSE STATUS LINE] -> ");
+ sb.append(((HttpMethodBase) _method).getParams().getVersion()
+ .equals(HttpVersion.HTTP_1_1) ? "HTTP/1.1 " : "HTTP/1.0 ");
+ sb.append(_method.getStatusCode()).append(' ');
+ sb.append(_method.getStatusText()).append('\n');
+ Header[] headers = _method.getResponseHeaders();
+ if (headers != null && headers.length != 0) {
+ for (int i = 0; i < headers.length; i++) {
+ sb.append(" [RESPONSE HEADER] -> ");
+ sb.append(headers[i].toExternalForm()).append('\n');
+ }
+ }
+
+ String resBody;
+ try {
+ resBody = _method.getResponseBodyAsString();
+ } catch (IOException ioe) {
+ resBody = "UNEXECTED EXCEPTION: " + ioe.toString();
+ }
+ if (resBody != null && resBody.length() != 0) {
+ sb.append("------ [RESPONSE BODY] ------\n");
+ sb.append(resBody);
+ sb.append("\n-----------------------------\n\n");
+ }
+ return sb.toString();
+ }
+
+ /*
+ * Eventually they need to come from _method
+ */
+
+ public String getHost() {
+ return _host;
+ }
+
+ public int getPort() {
+ return _port;
+ }
+
+ public String getProtocol() {
+ return _isSecure ? "https" : "http";
+ }
+
+ public String getPath() {
+ return _method.getPath();
+ }
+
+ /*
+ * Private Methods
+ * ==========================================================================
+ */
+
+ /**
+ * Returns the response body using the encoding returned in the response.
+ *
+ * @return encoded response String.
+ */
+ private String getEncodedResponse() throws IOException {
+ if (_responseBody == null) {
+ _responseBody = getEncodedStringFromStream(
+ _method.getResponseBodyAsStream(), getResponseEncoding());
+ }
+ return _responseBody;
+ }
+
+ public static String getEncodedStringFromStream(InputStream in, String enc)
+ throws IOException {
+ BufferedReader bin = new BufferedReader(new InputStreamReader(in, enc));
+ StringBuilder sb = new StringBuilder(128);
+ for (int ch = bin.read(); ch != -1; ch = bin.read()) {
+ sb.append((char) ch);
+ }
+ return sb.toString();
+ }
+
+}
diff --git a/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/MethodFactory.java b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/MethodFactory.java
new file mode 100644
index 0000000000..85ddaf8aee
--- /dev/null
+++ b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/MethodFactory.java
@@ -0,0 +1,164 @@
+/*
+ * Copyright (c) 2007, 2020 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/*
+ * $Id$
+ */
+
+package com.sun.ts.tests.servlet.common.request;
+
+import org.apache.commons.httpclient.HttpMethod;
+import org.apache.commons.httpclient.HttpMethodBase;
+import org.apache.commons.httpclient.HttpVersion;
+import org.apache.commons.httpclient.methods.DeleteMethod;
+import org.apache.commons.httpclient.methods.GetMethod;
+import org.apache.commons.httpclient.methods.HeadMethod;
+import org.apache.commons.httpclient.methods.OptionsMethod;
+import org.apache.commons.httpclient.methods.PostMethod;
+import org.apache.commons.httpclient.methods.PutMethod;
+
+import java.util.NoSuchElementException;
+import java.util.StringTokenizer;
+
+/**
+ * Simple factory class which returns HttpMethod implementations based on a
+ * request line.
+ *
+ * For example, a request line of GET /index.jsp HTTP/1.0 would return
+ * an HttpMethod implementation that handles GET requests using HTTP/1.0.
+ *
+ */
+
+public class MethodFactory {
+
+ /**
+ * HTTP GET
+ */
+ private static final String GET_METHOD = "GET";
+
+ /**
+ * HTTP POST
+ */
+ private static final String POST_METHOD = "POST";
+
+ /**
+ * HTTP HEAD
+ */
+ private static final String HEAD_METHOD = "HEAD";
+
+ /**
+ * HTTP PUT
+ */
+ private static final String PUT_METHOD = "PUT";
+
+ /**
+ * HTTP DELETE
+ */
+ private static final String DELETE_METHOD = "DELETE";
+
+ /**
+ * HTTP OPTIONS
+ */
+ private static final String OPTIONS_METHOD = "OPTIONS";
+
+ /**
+ * Private constructor as all interaction with this class is through the
+ * getInstance() method.
+ */
+ private MethodFactory() {
+ }
+
+ /*
+ * public methods
+ * ========================================================================
+ */
+
+ /**
+ * Returns the approriate request method based on the provided request string.
+ * The request must be in the format of METHOD URI_PATH HTTP_VERSION, i.e. GET
+ * /index.jsp HTTP/1.1.
+ *
+ * @return HttpMethod based in request.
+ */
+ public static HttpMethod getInstance(String request) {
+ StringTokenizer st = new StringTokenizer(request);
+ String method;
+ String query = null;
+ String uri;
+ String version;
+ try {
+ method = st.nextToken();
+ uri = st.nextToken();
+ version = st.nextToken();
+ } catch (NoSuchElementException nsee) {
+ throw new IllegalArgumentException(
+ "Request provided: " + request + " is malformed.");
+ }
+
+ // check to see if there is a query string appended
+ // to the URI
+ int queryStart = uri.indexOf('?');
+ if (queryStart != -1) {
+ query = uri.substring(queryStart + 1);
+ uri = uri.substring(0, queryStart);
+ }
+
+ HttpMethodBase req;
+
+ if (method.equals(GET_METHOD)) {
+ req = new GetMethod(uri);
+ } else if (method.equals(POST_METHOD)) {
+ req = new PostMethod(uri);
+ } else if (method.equals(PUT_METHOD)) {
+ req = new PutMethod(uri);
+ } else if (method.equals(DELETE_METHOD)) {
+ req = new DeleteMethod(uri);
+ } else if (method.equals(HEAD_METHOD)) {
+ req = new HeadMethod(uri);
+ } else if (method.equals(OPTIONS_METHOD)) {
+ req = new OptionsMethod(uri);
+ } else {
+ throw new IllegalArgumentException("Invalid method: " + method);
+ }
+
+ setHttpVersion(version, req);
+
+ if (query != null) {
+ req.setQueryString(query);
+ }
+
+ return req;
+ }
+
+ /*
+ * private methods
+ * ========================================================================
+ */
+
+ /**
+ * Sets the HTTP version for the method in question.
+ *
+ * @param version
+ * HTTP version to use for this request
+ * @param method
+ * method to adjust HTTP version
+ */
+ private static void setHttpVersion(String version, HttpMethodBase method) {
+ final String oneOne = "HTTP/1.1";
+ method.getParams().setVersion(
+ (version.equals(oneOne) ? HttpVersion.HTTP_1_1 : HttpVersion.HTTP_1_0));
+ }
+}
diff --git a/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/RequestClient.java b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/RequestClient.java
new file mode 100644
index 0000000000..e24c68b141
--- /dev/null
+++ b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/RequestClient.java
@@ -0,0 +1,368 @@
+/*
+ * Copyright (c) 2007, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/*
+ * $Id$
+ */
+
+package com.sun.ts.tests.servlet.common.request;
+
+import com.sun.ts.tests.servlet.common.client.AbstractUrlClient;
+import com.sun.ts.tests.servlet.common.util.Data;
+
+public class RequestClient extends AbstractUrlClient {
+
+
+ public void getAttributeNamesTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getAttributeNamesTest");
+ invoke();
+ }
+
+
+ public void getAttributeNamesEmptyEnumTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getAttributeNamesEmptyEnumTest");
+ invoke();
+ }
+
+
+ public void getAttributeTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getAttributeTest");
+ invoke();
+ }
+
+
+ public void getAttributeDoesNotExistTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getAttributeDoesNotExistTest");
+ invoke();
+ }
+
+
+ public void getCharacterEncodingTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getCharacterEncodingTest");
+ TEST_PROPS.setProperty(REQUEST_HEADERS,
+ "Content-Type:text/plain; charset=ISO-8859-1");
+ invoke();
+ }
+
+
+ public void getContentLengthTest() throws Exception {
+ String testName = "getContentLengthTest";
+ TEST_PROPS.setProperty(REQUEST, "POST " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(REQUEST_HEADERS, "Content-Type:text/plain");
+ TEST_PROPS.setProperty(CONTENT, "calling getContentLengthTest");
+ TEST_PROPS.setProperty(SEARCH_STRING, Data.PASSED);
+ invoke();
+ }
+
+
+ public void getContentTypeTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getContentTypeTest");
+ TEST_PROPS.setProperty(REQUEST_HEADERS, "Content-Type:text/plain");
+ invoke();
+ }
+
+
+ public void getContentTypeNullTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getContentTypeNullTest");
+ invoke();
+ }
+
+
+ public void getInputStreamTest() throws Exception {
+ String testName = "getInputStreamTest";
+ TEST_PROPS.setProperty(REQUEST, "POST " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(REQUEST_HEADERS, "Content-Type:text/plain");
+ TEST_PROPS.setProperty(CONTENT, "calling getInputStreamTest");
+ TEST_PROPS.setProperty(SEARCH_STRING, Data.PASSED);
+ invoke();
+ }
+
+
+ public void getInputStreamIllegalStateExceptionTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getInputStreamIllegalStateExceptionTest");
+ invoke();
+ }
+
+
+ public void getParameterValuesDoesNotExistTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getParameterValuesDoesNotExistTest");
+ invoke();
+ }
+
+
+ public void getLocaleTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getLocaleTest");
+ TEST_PROPS.setProperty(REQUEST_HEADERS, "Accept-Language:en-US");
+ invoke();
+ }
+
+
+ public void getLocaleDefaultTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getLocaleDefaultTest");
+ invoke();
+ }
+
+
+ public void getLocalesTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getLocalesTest");
+ TEST_PROPS.setProperty(REQUEST_HEADERS, "Accept-Language:en-US,en-GB");
+ invoke();
+ }
+
+
+ public void getLocalesDefaultTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getLocalesDefaultTest");
+ invoke();
+ }
+
+
+ public void getParameterMapTest() throws Exception {
+ String testName = "getParameterMapTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST,
+ "GET " + getContextRoot() + "/" + getServletName() + "?testname="
+ + testName + "¶meter1=value1¶meter2=value2 HTTP/1.1");
+ TEST_PROPS.setProperty(SEARCH_STRING, Data.PASSED);
+ invoke();
+ }
+
+
+ public void getParameterNamesTest() throws Exception {
+ String testName = "getParameterNamesTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST,
+ "GET " + getContextRoot() + "/" + getServletName() + "?testname="
+ + testName + "¶meter1=value1¶meter2=value2 HTTP/1.1");
+ TEST_PROPS.setProperty(SEARCH_STRING, Data.PASSED);
+ invoke();
+ }
+
+
+ public void getParameterNamesEmptyEnumTest() throws Exception {
+ String testName = "getParameterNamesEmptyEnumTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST,
+ "GET " + getContextRoot() + "/" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(SEARCH_STRING, Data.PASSED);
+ invoke();
+ }
+
+
+ public void getParameterTest() throws Exception {
+ String testName = "getParameterTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST,
+ "GET " + getContextRoot() + "/" + getServletName() + "?testname="
+ + testName + "¶meter1=value1 HTTP/1.1");
+ TEST_PROPS.setProperty(SEARCH_STRING, Data.PASSED);
+ invoke();
+ }
+
+
+ public void getParameterDoesNotExistTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getParameterDoesNotExistTest");
+ invoke();
+ }
+
+
+ public void getParameterValuesTest() throws Exception {
+ String testName = "getParameterValuesTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST,
+ "GET " + getContextRoot() + "/" + getServletName() + "?testname="
+ + testName + "&Names=value1&Names=value2 HTTP/1.1");
+ TEST_PROPS.setProperty(SEARCH_STRING, Data.PASSED);
+ invoke();
+ }
+
+
+ public void getProtocolTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getProtocolTest");
+ invoke();
+ }
+
+
+ public void getReaderTest() throws Exception {
+ String testName = "getReaderTest";
+ TEST_PROPS.setProperty(REQUEST, "POST " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(REQUEST_HEADERS, "Content-Type:text/plain");
+ TEST_PROPS.setProperty(CONTENT, "calling getReaderTest");
+ TEST_PROPS.setProperty(SEARCH_STRING, Data.PASSED);
+ invoke();
+ }
+
+
+ public void getReaderIllegalStateExceptionTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getReaderIllegalStateExceptionTest");
+ invoke();
+ }
+
+
+ public void getReaderUnsupportedEncodingExceptionTest() throws Exception {
+ String testName = "getReaderUnsupportedEncodingExceptionTest";
+ TEST_PROPS.setProperty(REQUEST,
+ "POST " + getContextRoot() + "/" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(REQUEST_HEADERS,
+ "Content-Type:text/plain; charset=DoesNonExist");
+ TEST_PROPS.setProperty(CONTENT,
+ "calling getReaderUnsupportedEncodingExceptionTest");
+ TEST_PROPS.setProperty(SEARCH_STRING, Data.PASSED);
+ invoke();
+ }
+
+
+ public void getRemoteAddrTest() throws Exception {
+ String localIps = getLocalInterfaceInfo(true);
+ String testName = "getRemoteAddrTest";
+ TEST_PROPS.setProperty(REQUEST,
+ "GET " + getContextRoot() + "/" + getServletName() + "?testname="
+ + testName + "&Address=" + localIps + " HTTP/1.1");
+ TEST_PROPS.setProperty(SEARCH_STRING, Data.PASSED);
+ invoke();
+ }
+
+
+ public void getLocalAddrTest() throws Exception {
+ String testName = "getLocalAddrTest";
+ TEST_PROPS.setProperty(APITEST, testName);
+ TEST_PROPS.setProperty(SEARCH_STRING, Data.PASSED);
+ invoke();
+ }
+
+
+ public void getRemoteHostTest() throws Exception {
+ String testName = "getRemoteHostTest";
+ String localIps = getLocalInterfaceInfo(true);
+ String localHosts = getLocalInterfaceInfo(false);
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST,
+ "GET " + getContextRoot() + "/" + getServletName() + "?testname="
+ + testName + "&Address=" + localIps + "," + localHosts
+ + " HTTP/1.1");
+ TEST_PROPS.setProperty(SEARCH_STRING, Data.PASSED);
+ invoke();
+ }
+
+
+ public void getRequestDispatcherTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getRequestDispatcherTest");
+ invoke();
+ }
+
+
+ public void getSchemeTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getSchemeTest");
+ invoke();
+ }
+
+
+ public void getServerNameTest() throws Exception {
+ String testName = "getServerNameTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST,
+ "GET " + getContextRoot() + "/" + getServletName() + "?testname="
+ + testName + "&hostname=" + _hostname + " HTTP/1.1");
+ TEST_PROPS.setProperty(SEARCH_STRING, Data.PASSED);
+ invoke();
+ }
+
+
+ public void getServerPortTest() throws Exception {
+ String testName = "getServerPortTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST,
+ "GET " + getContextRoot() + "/" + getServletName() + "?testname="
+ + testName + "&port=" + _port + " HTTP/1.1");
+ TEST_PROPS.setProperty(SEARCH_STRING, Data.PASSED);
+ invoke();
+ }
+
+
+ public void isSecureTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "isSecureTest");
+ invoke();
+ }
+
+
+ public void removeAttributeTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "removeAttributeTest");
+ invoke();
+ }
+
+
+ public void setAttributeTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "setAttributeTest");
+ invoke();
+ }
+
+
+ public void getCharacterEncodingNullTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getCharacterEncodingNullTest");
+ invoke();
+ }
+
+
+ public void setCharacterEncodingUnsupportedEncodingExceptionTest()
+ throws Exception {
+ String testName = "setCharacterEncodingUnsupportedEncodingExceptionTest";
+ TEST_PROPS.setProperty(REQUEST,
+ "POST " + getContextRoot() + "/" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(SEARCH_STRING, Data.PASSED);
+ invoke();
+ }
+
+
+ public void setCharacterEncodingTest() throws Exception {
+ String testName = "setCharacterEncodingTest";
+ TEST_PROPS.setProperty(REQUEST,
+ "POST " + getContextRoot() + "/" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(SEARCH_STRING, Data.PASSED);
+ invoke();
+ }
+
+
+ public void setCharacterEncodingTest1() throws Exception {
+ String testName = "setCharacterEncodingTest1";
+ TEST_PROPS.setProperty(APITEST, testName);
+ invoke();
+ }
+
+
+ public void getLocalNameTest() throws Exception {
+ String testName = "getLocalNameTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST,
+ "GET " + getContextRoot() + "/" + getServletName() + "?testname="
+ + testName + "&hostname=" + _hostname + " HTTP/1.1");
+ TEST_PROPS.setProperty(SEARCH_STRING, Data.PASSED);
+
+ invoke();
+ }
+
+
+ public void getLocalPortTest() throws Exception {
+ String testName = "getLocalPortTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST,
+ "GET " + getContextRoot() + "/" + getServletName() + "?testname="
+ + testName + "&hostport=" + _port + " HTTP/1.1");
+ TEST_PROPS.setProperty(SEARCH_STRING, Data.PASSED);
+ invoke();
+ }
+}
diff --git a/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/SecBasicClient.java b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/SecBasicClient.java
new file mode 100644
index 0000000000..5b9c373e8c
--- /dev/null
+++ b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/SecBasicClient.java
@@ -0,0 +1,449 @@
+/*
+ * Copyright (c) 2007, 2020 Oracle and/or its affiliates and others.
+ * All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package com.sun.ts.tests.servlet.common.request;
+
+import com.sun.ts.lib.util.TestUtil;
+import com.sun.ts.tests.servlet.common.client.BaseUrlClient;
+import org.junit.jupiter.api.Test;
+
+import java.util.Properties;
+
+public abstract class SecBasicClient extends BaseUrlClient {
+
+ // Constants:
+ private static final String USERNAME = "user";
+
+ private static final String PASSWORD = "password";
+
+ private static final String UNAUTH_USERNAME = "authuser";
+
+ private static final String UNAUTH_PASSWORD = "authpassword";
+
+ private static final String CLASS_TRACE_HEADER = "[SecBasicClient]: ";
+
+ private static final String USER_PRINCIPAL_SEARCH = "The user principal is: "; // (+username)
+
+ private static final String REMOTE_USER_SEARCH = "getRemoteUser(): "; // (+username)
+
+ // fields:
+ protected String pageSec = null;
+
+ protected String pageGuest = null;
+
+ protected String pageUnprotected = null;
+
+ protected String pageRoleReverse = null;
+
+ private String pageJspBase = "/jsp_sec_secbasic_web";
+
+ private String pageJspSec = pageJspBase + "/jspSec.jsp";
+
+ private String pageJspGuest = pageJspBase + "/guestPage.jsp";
+
+ private String pageJspUnprotected = pageJspBase + "/unprotected.jsp";
+
+ private String pageJspRoleReverse = pageJspBase + "/rolereverse.jsp";
+
+ private String pageServletBase = "/servlet_sec_secbasic_web";
+
+ private String pageServletSec = pageServletBase + "/ServletSecTest";
+
+ private String pageServletGuest = pageServletBase + "/GuestPageTest";
+
+ private String pageServletUnprotected = pageServletBase + "/UnProtectedTest";
+
+ private String pageServletRoleReverse = pageServletBase + "/RoleReverseTest";
+
+ private String username = null;
+
+ private String password = null;
+
+ private String unauthUsername = null;
+
+ private String unauthPassword = null;
+
+ /*
+ * @class.setup_props: webServerHost; webServerPort; user; password; authuser;
+ * authpassword; ts_home;
+ *
+ *
+ */
+
+ public void setup(String[] args, Properties p) throws Exception {
+ super.setup(args, p);
+
+ // TOFIX configurable
+// user=j2ee
+// password=j2ee
+// authuser=javajoe
+// authpassword=javajoe
+
+ p.setProperty(USERNAME, "j2ee");
+ p.setProperty(PASSWORD, "j2ee");
+ p.setProperty(UNAUTH_USERNAME, "javajoe");
+ p.setProperty(UNAUTH_PASSWORD, "javajoe");
+
+ try {
+ username = p.getProperty(USERNAME);
+ password = p.getProperty(PASSWORD);
+ unauthUsername = p.getProperty(UNAUTH_USERNAME);
+ unauthPassword = p.getProperty(UNAUTH_PASSWORD);
+
+
+ pageSec = pageServletSec;
+ pageGuest = pageServletGuest;
+ pageUnprotected = pageServletUnprotected;
+ pageRoleReverse = pageServletRoleReverse;
+
+
+ } catch (Exception e) {
+ logErr("Error: got exception: ", e);
+ }
+ }
+
+ /*
+ * testName: test1
+ *
+ * @assertion: Test BASIC authentication, specified in the Java Servlet
+ * Specification v2.2, Sec 11.5.1.
+ *
+ * 1. If user has not been authenticated and user attempts to access a
+ * protected web resource, the web server requests authentication.
+ *
+ * @test_Strategy: 1. Send request to access jspSec.jsp 2. Receive
+ * authentication request.
+ */
+
+ public void test1() throws Exception {
+ logMessage(
+ "Sending request to validate presence of www-authenticate header...");
+ TEST_PROPS.setProperty(TEST_NAME, "SecBasic/Test1");
+ TEST_PROPS.setProperty(REQUEST, getRequestLine("GET", pageSec));
+ TEST_PROPS.setProperty(EXPECTED_HEADERS, "www-authenticate:");
+ TEST_PROPS.setProperty(STATUS_CODE, UNAUTHORIZED);
+ invoke();
+
+ dumpResponse(); // debug aid
+
+ logMessage("Authentication requested");
+ }
+
+ /*
+ * testName: test2
+ *
+ * @assertion: Test BASIC authentication, specified in the Java Servlet
+ * Specification v2.2, Sec 11.5.1. Also tests API assertions in section 11.3.
+ *
+ * 1. If user has not been authenticated and user attempts to access a
+ * protected web resource, and user enters a valid username and password, the
+ * original web resource is returned and user is authenticated. 2.
+ * getRemoteUser() returns the user name that the client authenticated with.
+ *
+ * @test_Strategy: 1. Send request with correct authentication. 2. Receive
+ * page (ensure principal is correct, and ensure that getRemoteUser() returns
+ * the correct name)
+ */
+
+ public void test2() throws Exception {
+ logMessage("Sending request with Authroization header...");
+
+ StringBuffer sb = new StringBuffer(100);
+ sb.append(USER_PRINCIPAL_SEARCH).append(username).append("|");
+ sb.append(REMOTE_USER_SEARCH).append(username).append("|");
+ sb.append("isUserInRole(\"ADM\"): !true!").append("|");
+ sb.append("isUserInRole(\"MGR\"): !false!").append("|");
+ sb.append("isUserInRole(\"VP\"): !false!").append("|");
+ sb.append("isUserInRole(\"EMP\"): !true!").append("|");
+
+ TEST_PROPS.setProperty(TEST_NAME, "SecBasic/Test2");
+ TEST_PROPS.setProperty(REQUEST, getRequestLine("GET", pageSec));
+ TEST_PROPS.setProperty(BASIC_AUTH_USER, username);
+ TEST_PROPS.setProperty(BASIC_AUTH_PASSWD, password);
+ TEST_PROPS.setProperty(SEARCH_STRING, sb.toString());
+ invoke();
+
+ dumpResponse(); // debug aid
+
+ logMessage("isUserInRole() and getRemoteUser() returned expected results");
+ }
+
+ /*
+ * testName: test3
+ *
+ * @assertion: Test BASIC authentication, specified in the Java Servlet
+ * Specification v2.2, Sec 11.5.1.
+ *
+ * 1. If user has not been authenticated and user attempts to access a
+ * protected web resource, and user enters an invalid username and password,
+ * the container denies access to the web resource.
+ *
+ * @test_Strategy: 1. Re-send request with incorrect authentication. 2.
+ * Receive authentication request.
+ */
+
+ public void test3() throws Exception {
+ logMessage(
+ "Sending an request for a protected resource with invalid username/password...");
+
+ TEST_PROPS.setProperty(TEST_NAME, "SecBasic/Test3");
+ TEST_PROPS.setProperty(REQUEST, getRequestLine("GET", pageSec));
+ TEST_PROPS.setProperty(BASIC_AUTH_USER, "invalid");
+ TEST_PROPS.setProperty(BASIC_AUTH_PASSWD, password);
+ TEST_PROPS.setProperty(STATUS_CODE, UNAUTHORIZED);
+ invoke();
+
+ dumpResponse(); // debug aid
+
+ logMessage("Access Denied");
+ }
+
+ /*
+ * testName: test4
+ *
+ * @assertion: Test BASIC authentication, specified in the Java Servlet
+ * Specification v2.2, Sec 11.5.1.
+ *
+ * 1. If user has not been authenticated and user attempts to access a
+ * protected web resource, and user enters an valid username and password, but
+ * for a role that is not authorized to access the resource, the container
+ * denies access to the web resource.
+ *
+ * @test_Strategy: 1. Send request with correct authentication for user
+ * javajoe for a page javajoe is allowed to access. 2. Receive page (this
+ * verifies that the javajoe user is set up properly). 3. Send request with
+ * correct authentication, but incorrect authorization to access resource 4.
+ * Receive error
+ */
+
+ public void test4() throws Exception {
+
+ StringBuffer sb = new StringBuffer(100);
+ sb.append(USER_PRINCIPAL_SEARCH).append(unauthUsername);
+
+ logMessage("Sending request to resource the user has access to...");
+ TEST_PROPS.setProperty(TEST_NAME, "SecBasic/Test4");
+ TEST_PROPS.setProperty(REQUEST, getRequestLine("GET", pageGuest));
+ TEST_PROPS.setProperty(BASIC_AUTH_USER, unauthUsername);
+ TEST_PROPS.setProperty(BASIC_AUTH_PASSWD, unauthPassword);
+ TEST_PROPS.setProperty(SEARCH_STRING, sb.toString());
+ invoke();
+
+ dumpResponse(); // debug aid
+
+ logMessage("User successfully accessed the resource");
+
+ logMessage(
+ "Sending request to resource with valid username/password, but not the right roles...");
+ TEST_PROPS.setProperty(TEST_NAME, "SecBasic/Test4");
+ TEST_PROPS.setProperty(REQUEST, getRequestLine("GET", pageSec));
+ TEST_PROPS.setProperty(BASIC_AUTH_USER, unauthUsername);
+ TEST_PROPS.setProperty(BASIC_AUTH_PASSWD, unauthPassword);
+ TEST_PROPS.setProperty(STATUS_CODE, FORBIDDEN);
+ invoke();
+
+ dumpResponse(); // debug aid
+
+ logMessage("Access Forbidden");
+ }
+
+ /*
+ * testName: test5
+ *
+ * @assertion: Test BASIC authentication, specified in the Java Servlet
+ * Specification v2.2, Sec 11.5.1. Also tests assertions in section 11.3.
+ *
+ * 1. If user has not been authenticated and user attempts to access an
+ * unprotected web resource, the web resource is returned without need to
+ * authenticate. 2. isUserInRole() must return false for any valid or invalid
+ * role reference. 3. getRemoteUser() must return false
+ *
+ * @test_Strategy: 1. Send request for unprotected.jsp with no authentication.
+ * 2. Receive page 3. Search the returned page for "!true!", which would
+ * indicate that at least one call to isUserInRole attempted by
+ * unprotected.jsp returned true. 4. check that getRemoteUser() returns null.
+ */
+
+ public void test5() throws Exception {
+ StringBuffer sb = new StringBuffer(100);
+ sb.append(USER_PRINCIPAL_SEARCH).append("|");
+ sb.append(REMOTE_USER_SEARCH).append("null");
+
+ logMessage("Sending request to unprotected resource....");
+ TEST_PROPS.setProperty(TEST_NAME, "BasicSec/Test5");
+ TEST_PROPS.setProperty(REQUEST, getRequestLine("GET", pageUnprotected));
+ TEST_PROPS.setProperty(SEARCH_STRING, sb.toString());
+ TEST_PROPS.setProperty(UNEXPECTED_RESPONSE_MATCH, "!true!");
+ invoke();
+
+ dumpResponse(); // debug aid
+
+ logMessage("isUserInRole() and getRemoteUser() returned expected results");
+ }
+
+ /*
+ * testName: test6
+ *
+ * @assertion: Test HTTP-Basic authentication, specified in the Java Servlet
+ * Specification v2.2, Sec 11.5.1. Also tests assertions from section 11.3.
+ *
+ * Given two servlets in the same application, each of which calls
+ * isUserInRole(X), and where X is linked to different roles in the scope of
+ * each of the servlets (i.e. R1 for servlet 1 and R2 for servlet 2), then a
+ * user whose identity is mapped to R1 but not R2, shall get a true return
+ * value from isUserInRole( X ) in servlet 1, and a false return value from
+ * servlet 2 (a user whose identity is mapped to R2 but not R1 should get the
+ * inverse set of return values).
+ *
+ * @test_Strategy: Since test1 already verifies the functionality for
+ * isUserInRole returning true, this test needs only verify that it should
+ * return false for the other jsp. For this test, MGR and ADM are swapped, so
+ * isUserInRole() should return opposite values from test1.
+ *
+ * 1. Send request to access rolereverse.jsp 2. Receive redirect to login
+ * page, extract location and session id cookie. 3. Send request to access new
+ * location, send cookie 4. Receive login page 5. Send form response with
+ * username and password 6. Receive redirect to resource 7. Request resource
+ * 8. Receive resource (check isUserInRole for all known roles)
+ */
+
+ public void test6() throws Exception {
+
+ StringBuffer sb = new StringBuffer(100);
+ sb.append(USER_PRINCIPAL_SEARCH).append(username).append("|");
+ sb.append("isUserInRole(\"ADM\"): !false!").append("|");
+ sb.append("isUserInRole(\"MGR\"): !true!").append("|");
+ sb.append("isUserInRole(\"VP\"): !false!").append("|");
+ sb.append("isUserInRole(\"EMP\"): !true!").append("|");
+
+ logMessage(
+ "Sending request to validate isUserInRole with roles reversed...");
+ TEST_PROPS.setProperty(TEST_NAME, "SecBasic/Test6");
+ TEST_PROPS.setProperty(REQUEST, getRequestLine("GET", pageRoleReverse));
+ TEST_PROPS.setProperty(BASIC_AUTH_USER, username);
+ TEST_PROPS.setProperty(BASIC_AUTH_PASSWD, password);
+ TEST_PROPS.setProperty(SEARCH_STRING, sb.toString());
+ invoke();
+
+ dumpResponse(); // debug aid
+
+ logMessage("isUserInRole() and getRemoteUser() returned expected results");
+ }
+
+ /*
+ * testName: test7
+ *
+ * @assertion: Test BASIC authentication, specified in the Java Servlet
+ * Specification v2.2, Sec 11.5.1.
+ *
+ * 1. If user has not been authenticated and user attempts to access a
+ * protected web resource+ , and user enters an invalid
+ * username and password, the container denies access to the web resource.
+ * IMPORTANT: this is not just trying to access a protected resource but
+ * instead is trying to access pageSec + "/j_security_check" when
+ * unauthenticated in an attempt to trick/confuse the impl into thinking
+ * authentication occurred when it did not.
+ *
+ * @test_Strategy: 1. send request with incorrect authentication to url +
+ * "/j_security_check" 2. Receive authentication request.
+ */
+
+ public void test7() throws Exception {
+ logMessage(
+ "Sending an request for a protected resource with invalid username/password...");
+
+ TEST_PROPS.setProperty(TEST_NAME, "SecBasic/Test7");
+ TEST_PROPS.setProperty(REQUEST,
+ getRequestLine("GET", pageSec + "/j_security_check"));
+ TEST_PROPS.setProperty(BASIC_AUTH_USER, "invalid");
+ TEST_PROPS.setProperty(BASIC_AUTH_PASSWD, password);
+ // The servlet is mapped to "/ServletSecTest" so this request should result
+ // in a 404 since no Servlet is mapped to the requested URI or 401 if the container
+ // rejects the incoming BASIC header.
+ TEST_PROPS.setProperty(STATUS_CODE, UNAUTHORIZED + "," + NOT_FOUND);
+ invoke();
+
+ dumpResponse(); // debug aid
+
+ if ((_testCase != null) && (_testCase.getResponse() != null)) {
+ // we got a response so lets check it...
+ // if our search string appears in the response, we were erroneously
+ // allowed access to a protected page!
+ String searchString = "Inside ServletSecTestServlet";
+ try {
+ if (_testCase.getResponse().getResponseBodyAsString()
+ .indexOf(searchString) != -1) {
+ // ohoh - we should NOT have been allowed to access the page and it
+ // appears we did access it. log an error
+ TestUtil.logErr("(Should say: \"" + searchString + "\")");
+ throw new Exception("test7 failed.");
+ }
+ } catch (Exception ex) {
+ // must've had problem getting response so dump exception but continue
+ // on
+ ex.printStackTrace();
+ }
+ }
+
+ logMessage("Access properly Denied");
+ }
+
+ /**
+ * Returns a valid HTTP/1.1 request line.
+ *
+ * @param method
+ * the request method
+ * @param path
+ * the request path
+ * @return a valid HTTP/1.1 request line
+ */
+ private static String getRequestLine(String method, String path) {
+ return method + " " + path + " HTTP/1.1";
+ }
+
+ /**
+ * Simple wrapper around TestUtil.logMessage().
+ *
+ * @param message
+ * - the message to log
+ */
+ private static void logMessage(String message) {
+ TestUtil.logMsg(CLASS_TRACE_HEADER + message);
+ }
+
+ /**
+ * Simple wrapper around TestUtil.logTrace().
+ *
+ * @param message
+ * - the message to log
+ */
+ private static void trace(String message) {
+ TestUtil.logTrace(CLASS_TRACE_HEADER + message);
+ }
+
+ private void dumpResponse() {
+ try {
+ if ((_testCase != null) && (_testCase.getResponse() != null)) {
+ trace(_testCase.getResponse().getResponseBodyAsString());
+ }
+ } catch (Exception ex) {
+ // must've had problem getting response so dump exception but continue on
+ ex.printStackTrace();
+ }
+ }
+
+}
diff --git a/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/SecformClient.java b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/SecformClient.java
new file mode 100644
index 0000000000..c5e079ab6d
--- /dev/null
+++ b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/SecformClient.java
@@ -0,0 +1,2304 @@
+/*
+ * Copyright (c) 2007, 2020 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package com.sun.ts.tests.servlet.common.request;
+
+import com.sun.ts.lib.util.TestUtil;
+import com.sun.ts.lib.util.WebUtil;
+import com.sun.ts.lib.util.WebUtil.Response;
+import com.sun.ts.tests.servlet.common.client.BaseUrlClient;
+import org.junit.jupiter.api.Test;
+
+import java.io.BufferedReader;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.net.ConnectException;
+import java.net.InetAddress;
+import java.net.MalformedURLException;
+import java.net.Socket;
+import java.net.URL;
+import java.net.UnknownHostException;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.Hashtable;
+import java.util.List;
+import java.util.Properties;
+import java.util.StringTokenizer;
+
+public class SecformClient extends BaseUrlClient {
+ // Configurable constants:
+
+ private String protocol = "http";
+
+ private String hostname = null;
+
+ private int portnum = 0;
+
+ protected String pageBase = null;
+
+ protected String pageSec = null;
+
+ protected String pageGuest = null;
+
+ protected String pageRoleReverse = null;
+
+ protected String pageUnprotected = null;
+
+ private String pageProgAuthen = null;
+
+ private String pageProgLogin = null;
+
+ private String pageProgLogout = null;
+
+ private String pageOne = null;
+
+ private String pageTwo = null;
+
+ private String pageSample = null;
+
+ private String pageallRoles = null;
+
+ // common for JSP and Servlet
+ private String pageLogin = "/login.jsp";
+
+ private String pageError = "/error.jsp";
+
+ private String pageSecurityCheck = "/j_security_check";
+
+ private String pageJspBase = "/jsp_sec_secform_web";
+
+ private String pageJspSec = pageJspBase + "/jspSec.jsp";
+
+ private String pageJspUnprotected = pageJspBase + "/unprotected.jsp";
+
+ private String pageJspGuest = pageJspBase + "/guestPage.jsp";
+
+ private String pageJspRoleReverse = pageJspBase + "/rolereverse.jsp";
+
+ private String pageJspOne = pageJspBase + "/One.jsp";
+
+ private String pageJspTwo = pageJspBase + "/Two.jsp";
+
+ private String pageJspSample = pageJspBase + "/Sample.jsp";
+
+ private String pageJspallRoles = pageJspBase + "/allRoles.jsp";
+
+ private String pageServletBase = "/servlet_sec_secform_web";
+
+ private String pageServletSec = pageServletBase + "/ServletSecTest";
+
+ private String pageServletUnprotected = pageServletBase + "/UnProtectedTest";
+
+ private String pageServletProgLogin = pageServletBase
+ + "/ServletProgrammaticLogin";
+
+ private String pageServletProgLogout = pageServletBase
+ + "/ServletProgrammaticLogout";
+
+ private String pageServletProgAuthen = pageServletBase
+ + "/ServletProgrammaticAuthen";
+
+ private String pageServletGuest = pageServletBase + "/GuestPageTest";
+
+ private String pageServletRoleReverse = pageServletBase + "/RoleReverseTest";
+
+ private String pageServletOne = pageServletBase + "/OneTest";
+
+ private String pageServletTwo = pageServletBase + "/TwoTest";
+
+ private String pageServletSample = pageServletBase + "/SampleTest";
+
+ private String pageServletallRoles = pageServletBase + "/allRolesTest";
+
+ private String searchFor = "The user principal is: "; // (+username)
+
+ private String searchForGetRemoteUser = "getRemoteUser(): "; // (+username)
+
+ private String username = "";
+
+ private String password = "";
+
+ private String unauthUsername = "";
+
+ private String unauthPassword = "";
+
+ private String tshome = "";
+
+ // Constants:
+ private final String WebHostProp = "webServerHost";
+
+ private final String WebPortProp = "webServerPort";
+
+ private final String UserNameProp = "user";
+
+ private final String PasswordProp = "password";
+
+ private final String unauthUserNameProp = "authuser";
+
+ private final String unauthPasswordProp = "authpassword";
+
+ private final String tsHomeProp = "ts_home";
+
+ private String testDir = System.getProperty("user.dir");
+
+ // Shared test variables:
+ private Properties props = null;
+
+ private String request = null;
+
+ private Response response = null;
+
+ private Response loginPageRequestResponse = null;
+
+ private Response errorPageRequestResponse = null;
+
+ private Hashtable cookies = null;
+
+ /*
+ * @class.setup_props: webServerHost; webServerPort; user; password; authuser;
+ * authpassword; ts_home;
+ */
+ public void setup(String[] args, Properties p) throws Exception {
+ super.setup(args, p);
+ props = p;
+
+ try {
+ hostname = p.getProperty(WebHostProp);
+ portnum = Integer.parseInt(p.getProperty(WebPortProp));
+ username = p.getProperty(UserNameProp);
+ password = p.getProperty(PasswordProp);
+ unauthUsername = p.getProperty(unauthUserNameProp);
+ unauthPassword = p.getProperty(unauthPasswordProp);
+ tshome = p.getProperty(tsHomeProp);
+
+ logger.debug("username: {}", username);
+ logger.debug("password: {}", password);
+
+// if (args[0].equals("jsp")) {
+// pageBase = pageJspBase;
+// pageSec = pageJspSec;
+// pageGuest = pageJspGuest;
+// pageUnprotected = pageJspUnprotected;
+// pageRoleReverse = pageJspRoleReverse;
+// pageOne = pageJspOne;
+// pageTwo = pageJspTwo;
+// pageSample = pageJspSample;
+// pageallRoles = pageJspallRoles;
+//
+// // prefix pageJspBase to pageLogin, pageError ,pageSecurityCheck
+// pageLogin = pageJspBase + pageLogin;
+// pageError = pageJspBase + pageError;
+// pageSecurityCheck = pageJspBase + pageSecurityCheck;
+//
+// } else {
+ pageBase = pageServletBase;
+ pageSec = pageServletSec;
+ pageGuest = pageServletGuest;
+ pageUnprotected = pageServletUnprotected;
+ pageRoleReverse = pageServletRoleReverse;
+ pageOne = pageServletOne;
+ pageTwo = pageServletTwo;
+ pageSample = pageServletSample;
+ pageallRoles = pageServletallRoles;
+ pageProgLogin = pageServletProgLogin;
+ pageProgLogout = pageServletProgLogout;
+ pageProgAuthen = pageServletProgAuthen;
+
+ // prefix pageServletBase to pageLogin, pageError, pageSecurityCheck
+ pageLogin = pageServletBase + pageLogin;
+ pageError = pageServletBase + pageError;
+ pageSecurityCheck = pageServletBase + pageSecurityCheck;
+
+// }
+
+ } catch (Exception e) {
+ logger.error("Error: got exception: " + e.getMessage(), e);
+ }
+ }
+
+ /*
+ * testName: test1
+ *
+ * @assertion: Test FORM-based authentication, specified in the Java Servlet
+ * Specification v2.2, Sec 11.5.3. Also tests an assertion in section 11.3.
+ *
+ * 1. If user has not been authenticated and user attempts to access a
+ * protected web resource, the correct login form is returned. 2. If user has
+ * not been authenticated and user attempts to access a protected web
+ * resource, and user enters a valid username and password, the original web
+ * resource is returned and user is authenticated. A call to getRemoteUser()
+ * must return the username. 3. If user has been authenticated and user is
+ * authorized to access a protected web resource, user gets web resource
+ * without the need to re-authenticate. A call to getRemoteUser() still
+ * returns the username.
+ *
+ * @test_Strategy: 1. Send request to access jspSec.jsp 2. Receive login
+ * page(make sure it the expected login page) 3. Send form response with
+ * username and password 4. Receive jspSec.jsp (ensure principal is correct,
+ * and ensure getRemoteUser() returns the username, and ensure isUserInRole()
+ * is working properly) 5. Re-request jspSec.jsp 6. Ensure principal is still
+ * correct and getRemoteUser() still returns the correct username. Also ensure
+ * isUserInRole() is still working properly.
+ */
+
+ public void test1() throws Exception {
+ try {
+ // The first part of this test is used in test2 and test3 as
+ // well, so the code has been moved to a helper method.
+ requestAndGetLoginPage(pageSec, 1);
+
+ // Send response to login form with session id cookie:
+ request = pageSecurityCheck;
+ logger.debug("Sending request '{}' with login information.", request);
+ Properties postData = new Properties();
+ postData.setProperty("j_username", username);
+ postData.setProperty("j_password", password);
+ response = WebUtil.sendRequest("POST", InetAddress.getByName(hostname),
+ portnum, request, postData, cookies);
+
+ logger.debug("response.statusToken: {}", response.statusToken);
+ logger.debug("response.content: {}", response.content);
+
+ // Check that the page was found (no error).
+ if (response.isError()) {
+ logger.error("Could not find {}", request);
+ throw new Exception("test1 failed.");
+ }
+
+ // Call followRedirect() to make sure we receive the required page
+ response = followRedirect(response, 1);
+
+ // Print response content
+ logger.debug("received response content 1: {}", response.content);
+
+ // Check to make sure we are authenticated by checking the page
+ // content. The jsp should output "The user principal is: j2ee"
+ String searchString = searchFor + username;
+ if (response.content.indexOf(searchString) == -1) {
+ logger.error("User Principal incorrect. Page received:");
+ logger.error(response.content);
+ logger.error("(Should say: \"" + searchString + "\")");
+ throw new Exception("test1 failed.");
+ }
+ logger.debug("User Principal correct.");
+
+ // Check to make sure getRemoteUser returns the user name.
+ searchString = searchForGetRemoteUser + username;
+ if (response.content.indexOf(searchString) == -1) {
+ logger.error("getRemoteUser() did not return " + username + ":");
+ logger.error(response.content);
+ logger.error("(Should say: \"" + searchString + "\")");
+ throw new Exception("test1 failed.");
+ }
+ logMsg("getRemoteUser() correct.");
+
+ // Check to make sure isUserInRole is working properly:
+ Hashtable roleCheck = new Hashtable();
+ roleCheck.put("ADM", Boolean.TRUE);
+ roleCheck.put("MGR", Boolean.FALSE);
+ roleCheck.put("VP", Boolean.FALSE);
+ roleCheck.put("EMP", Boolean.TRUE);
+ // roleCheck.put( "Administrator", new Boolean( false ) );
+ if (!checkRoles(response.content, roleCheck)) {
+ logger.error("isUserInRole() does not work correctly. Page Received:");
+ logger.error(response.content);
+ throw new Exception("test1 failed.");
+ }
+ logMsg("isUserInRole() correct.");
+
+ // Now that we are authenticated, try accessing the resource again
+ // to ensure we need not go through the login page again.
+ request = pageSec;
+ logger.debug("Cookies = {}", cookies.toString());
+ logger.debug("Re-sending request {}", request);
+ response = WebUtil.sendRequest("GET", InetAddress.getByName(hostname),
+ portnum, request, null, cookies);
+
+ // Check that the page was found (no error).
+ if (response.isError()) {
+ logger.error("Could not find " + pageSec);
+ throw new Exception("test1 failed.");
+ }
+
+ // Check to make sure we are still authenticated.
+ if (response.content.indexOf(searchString) == -1) {
+ logger.error("User Principal incorrect. Page received:");
+ logger.error(response.content);
+ logger.error("(Should say: \"" + searchString + "\")");
+ throw new Exception("test1 failed.");
+ }
+ logger.debug("User Principal still correct.");
+
+ // Check to make sure getRemoteUser still returns the user name.
+ searchString = searchForGetRemoteUser + username;
+ if (response.content.indexOf(searchString) == -1) {
+ logger.error("getRemoteUser() did not return " + username
+ + " after lazy authentication:");
+ logger.error(response.content);
+ logger.error("(Should say: \"" + searchString + "\")");
+ throw new Exception("test1 failed.");
+ }
+ logMsg("getRemoteUser() still correct.");
+
+ // Check to make sure isUserInRole is still working properly:
+ if (!checkRoles(response.content, roleCheck)) {
+ logger.error("isUserInRole() does not work correctly.");
+ logger.error("Page Received:");
+ logger.error(response.content);
+ throw new Exception("test1 failed.");
+ }
+ logMsg("isUserInRole() still correct.");
+
+ } catch (Exception e) {
+ logger.error("Caught exception: " + e.getMessage(), e);
+ throw new Exception("test1 failed: " + e.getMessage(), e);
+ }
+ }
+
+ /*
+ * testName: test2
+ *
+ * @assertion: Test FORM-based authentication, specified in the Java Servlet
+ * Specification v2.2, Sec 11.5.3.
+ *
+ * If user has not been authenticated and user attempts to access a protected
+ * web resource, and user enters incorrect username and password, the error
+ * page is returned.
+ *
+ * @test_Strategy: 1. Send request to access jspSec.jsp 2. Receive login page
+ * 3. Send form response with username and incorrect password 4. Receive error
+ * page (make sure it is the expected error page)
+ */
+
+ public void test2() throws Exception {
+ try {
+ // The first part of this test is used in test1 and test3 as
+ // well, so the code has been moved to a helper method.
+ requestAndGetLoginPage(pageSec, 2);
+
+ // Send response to login form with session id cookie and username
+ // and incorrect password:
+ request = pageSecurityCheck;
+ logger.debug("Sending request {} with incorrect login information.", request);
+ Properties postData = new Properties();
+ postData.setProperty("j_username", username);
+ postData.setProperty("j_password", "incorrect" + password);
+ response = WebUtil.sendRequest("POST", InetAddress.getByName(hostname),
+ portnum, request, postData, cookies);
+ logger.debug("response.statusToken: {}", response.statusToken);
+
+ // Call followRedirect() to make sure we receive the required page
+ response = followRedirect(response, 2);
+
+ // Check to make sure the user principal is null:
+ String searchString = searchFor + "null";
+ if (response.content.indexOf(searchString) == -1) {
+ logger.error("User principal is not null in error page: {}", response.content);
+ throw new Exception("test2 failed.");
+ }
+
+ logger.debug("User Principal is null as expected.");
+
+ // Request error page
+ request = pageError;
+ logger.debug("Sending request {}", request);
+ errorPageRequestResponse = WebUtil.sendRequest("GET",
+ InetAddress.getByName(hostname), portnum, request,
+ null, cookies);
+
+ // Check that the page was found (no error).
+ if (errorPageRequestResponse.isError()) {
+ logger.error("Could not find {}", request);
+ throw new Exception("test2 failed.");
+ }
+
+ // Compare the received error page with the expected error page
+ // i.e Check whether
+ // response.content ==errorPageRequestResponse.content
+ if (response.content.equals(errorPageRequestResponse.content)) {
+ logger.debug("Received the expected error page");
+ } else {
+ logger.error("Received incorrect error page");
+ throw new Exception("test2 failed.");
+ }
+
+ } catch (Exception e) {
+ logger.error("Caught exception: " + e.getMessage(), e);
+ throw new Exception("test2 failed: " + e.getMessage(), e);
+ }
+ }
+
+ /*
+ * testName: test3
+ *
+ * @assertion: Test FORM-based authentication, specified in the Java Servlet
+ * Specification v2.2, Sec 11.5.3.
+ *
+ * If user has not been authenticated and user attempts to access a protected
+ * web resource, and user enters correct username and password of a user that
+ * is authorized to access the resource, the resource is returned (similar to
+ * test1, but uses user javajoe instead of j2ee). This test establishes that
+ * the javajoe user is set up properly.
+ *
+ * @test_Strategy: 1. Send request to access guestPage.jsp 2. Receive login
+ * page 3. Send form response with username(javajoe) and password 4. Receive
+ * resource (check user principal)
+ *
+ */
+
+ public void test3() throws Exception {
+ try {
+ // The first part of this test is used in test2 and test3 as
+ // well, so the code has been moved to a helper method.
+ requestAndGetLoginPage(pageGuest, 3);
+
+ // Send response to login form with session id cookie:
+ request = pageSecurityCheck;
+ logger.debug("Sending request {} with login information (as {}).", request, unauthUsername);
+ Properties postData = new Properties();
+ postData.setProperty("j_username", unauthUsername);
+ postData.setProperty("j_password", unauthPassword);
+ response = WebUtil.sendRequest("POST", InetAddress.getByName(hostname),
+ portnum, request, postData, cookies);
+
+ // Check that the page was found (no error).
+ if (response.isError()) {
+ logger.error("Could not find {}", request);
+ throw new Exception("test3 failed.");
+ }
+
+ // Call followRedirect() to make sure we receive the required page
+ response = followRedirect(response, 3);
+
+ // Check to make sure we are authenticated by checking the page
+ // content. The jsp should output "The user principal is: javajoe"
+ String searchString = searchFor + unauthUsername;
+ if (response.content.indexOf(searchString) == -1) {
+ logger.error("User Principal incorrect. Page received: {}", response.content);
+ logger.error("(Should say: {}", searchString);
+ throw new Exception("test3 failed.");
+ }
+ logger.debug("User Principal correct.");
+ } catch (Exception e) {
+ logErr("Caught exception: " + e.getMessage(), e);
+ throw new Exception("test3 failed: " + e.getMessage(), e);
+ }
+ }
+
+ /*
+ * testName: test4
+ *
+ * @assertion: Test FORM-based authentication, specified in the Java Servlet
+ * Specification v2.2, Sec 11.5.3.
+ *
+ * If user has not been authenticated and user attempts to access a protected
+ * web resource, and user enters correct username and password of a user that
+ * is not authorized to access the resource, the resource is not returned. The
+ * authenticated user is not denied access to an unprotected page.
+ *
+ * @test_Strategy: 1. Send request to access jspSec.jsp 2. Receive login page
+ * 3. Send form response with username and password 4. Receive an error
+ * (expected unauthorized error) 5. Send request to access unprotected.jsp 6.
+ * Receive unprotected.jsp.
+ */
+
+ public void test4() throws Exception {
+ try {
+ // The first part of this test is used in test1 and test2 as
+ // well, so the code has been moved to a helper method.
+ requestAndGetLoginPage(pageSec, 4);
+
+ // Send response to login form with session id cookie and username
+ // and password:
+ request = pageSecurityCheck;
+ logger.debug("Sending request {} with correct login information ({}), but incorrect authorization for this resource.",
+ request, unauthUsername);
+ Properties postData = new Properties();
+ postData.setProperty("j_username", unauthUsername);
+ postData.setProperty("j_password", unauthPassword);
+ response = WebUtil.sendRequest("POST", InetAddress.getByName(hostname),
+ portnum, request, postData, cookies);
+
+ logger.debug("response.content = {}", response.content);
+
+ if (response.statusToken.equals("302")) {
+ // We should receive a redirection page
+ if (response.location == null) {
+ logger.error("No redirection to login page received.");
+ throw new Exception("test4 failed.");
+ }
+
+ // Extract location from redirection and format new request:
+ request = WebUtil.getRequestFromURL(response.location);
+ logger.debug("Redirect to: {}", response.location);
+
+ // update cookies if the webserver choose to send cookies
+ addNewCookies(cookies, response.cookies);
+
+ // Request redirected page (login page):
+ logger.debug("Sending request {}", request);
+ response = WebUtil.sendRequest("GET", InetAddress.getByName(hostname),
+ portnum, request, null, cookies);
+ }
+
+ // Receive "403" or "404" error code for unauthorized access (forbidden).
+ if ((response.statusToken.equals("403"))
+ || (response.statusToken.equals("404"))) {
+ logger.debug("Status Token {}, Received expected unauthorized access error", response.statusToken);
+ } else {
+ logger.error("Did not receive error for unauthorized access: {}", request);
+ logger.error("Status Token {}", response.statusToken);
+ logger.error("Page content: {}", response.content);
+ throw new Exception("test4 failed.");
+ }
+
+ // Request unprotected page (unprotected.jsp page):
+ request = pageUnprotected;
+ logger.debug("Sending request {}", request);
+ response = WebUtil.sendRequest("GET", InetAddress.getByName(hostname),
+ portnum, request, null, null);
+
+ // Check that we did not receive an error and that we did not
+ // receive a redirection:
+ if (response.isError()) {
+ logger.error("Error retrieving {}", request);
+ throw new Exception("test4 failed.");
+ }
+
+ // Check that the page returned is the correct one. The principal
+ // is not checked.
+ String searchString = searchFor;
+ if (!response.content.contains(searchString)) {
+ logger.error("Incorrect page received: {}", response.content);
+ logger.error("(Should contain: {}", searchString);
+ throw new Exception("test4 failed.");
+ }
+ logger.debug("Access to unprotected page granted.");
+
+ } catch (Exception e) {
+ logger.error("Caught exception: " + e.getMessage(), e);
+ throw new Exception("test4 failed: " + e.getMessage(), e);
+ }
+ }
+
+ /*
+ * testName: test5
+ *
+ * @assertion: Test FORM-based authentication, specified in the Java Servlet
+ * Specification v2.2, Sec 11.5.3. Also tests assertions from section 11.3.
+ *
+ * If user has not been authenticated and user attempts to access an
+ * unprotected web resource, the resource is returned, and the user is not
+ * forced to authenticate. Also, isUserInRole() must return false for any
+ * valid or invalid role reference. A call to getRemoteUser() must return
+ * null.
+ *
+ * @test_Strategy: 1. Send request to access unprotected.jsp 2. Receive
+ * unprotected.jsp 3. Search the returned page for "!true!", which would
+ * indicate that at least one call to isUserInRole attempted by
+ * unprotected.jsp returned true. 4. Check that the call to getRemoteUser()
+ * returned null.
+ */
+
+ public void test5() throws Exception {
+ try {
+ // Request restricted jsp page.
+ String request = pageUnprotected;
+ logMsg("Sending request \"" + request + "\"");
+ response = WebUtil.sendRequest("GET", InetAddress.getByName(hostname),
+ portnum, request, null, null);
+
+ // Check that the page was found (no error).
+ if (response.isError()) {
+ logErr("Could not find " + pageUnprotected);
+ throw new Exception("test5 failed.");
+ }
+
+ // Check that we did not receive an error and that we did not
+ // receive a redirection:
+ if (response.isError()) {
+ logErr("Error retrieving " + request);
+ throw new Exception("test5 failed.");
+ }
+
+ // Check that the page returned is the correct one. The principal
+ // is not checked.
+ String searchString = searchFor;
+ if (response.content.indexOf(searchString) == -1) {
+ logErr("Incorrect page received:");
+ logErr(response.content);
+ logErr("(Should contain: \"" + searchString + "\")");
+ throw new Exception("test5 failed.");
+ }
+
+ logMsg("Access to unprotected page granted.");
+
+ // Check to see if any of the calls to isUserInRole returned true:
+ logMsg("Checking isUserInRole...");
+ searchString = "!true!";
+ if (response.content.indexOf(searchString) != -1) {
+ logErr("At least one call to isUserInRole returned true.");
+ logErr("Page received:");
+ logErr(response.content);
+ throw new Exception("test5 failed.");
+ }
+
+ logMsg("isUserInRole test passed.");
+
+ // Check to make sure the call to getRemoteUser() returned null.
+ logMsg("Checking getRemoteUser()...");
+ searchString = searchForGetRemoteUser + "null";
+ if (response.content.indexOf(searchString) == -1) {
+ logErr("A call to getRemoteUser() did not return null.");
+ logErr("Page received:");
+ logErr(response.content);
+ throw new Exception("test5 failed.");
+ }
+ logMsg("getRemoteUser() test passed.");
+
+ } catch (Exception e) {
+ logErr("Caught exception: " + e.getMessage());
+ e.printStackTrace();
+ throw new Exception("test5 failed: ", e);
+ }
+ }
+
+ /*
+ * testName: test6
+ *
+ * @assertion: Test FORM-based authentication, specified in the Java Servlet
+ * Specification v2.2, Sec 11.5.3. Also tests assertions from section 11.3.
+ *
+ * Given two servlets in the same application, each of which calls
+ * isUserInRole(X), and where X is linked to different roles in the scope of
+ * each of the servlets (i.e. R1 for servlet 1 and R2 for servlet 2), then a
+ * user whose identity is mapped to R1 but not R2, shall get a true return
+ * value from isUserInRole( X ) in servlet 1, and a false return value from
+ * servlet 2 (a user whose identity is mapped to R2 but not R1 should get the
+ * inverse set of return values).
+ *
+ * @test_Strategy: Since test1 already verifies the functionality for
+ * isUserInRole returning true, this test needs only verify that it should
+ * return false for the other jsp. For this test, MGR and ADM are swapped, so
+ * isUserInRole() should return opposite values from test1.
+ *
+ * 1. Send request to access rolereverse.jsp 2. Receive login page 3. Send
+ * form response with username and password 4. Receive resource (check
+ * isUserInRole for all known roles)
+ */
+
+ public void test6() throws Exception {
+ try {
+ // The first part of this test is used in test2 and test3 as
+ // well, so the code has been moved to a helper method.
+ requestAndGetLoginPage(pageRoleReverse, 6);
+
+ // Send response to login form with session id cookie:
+ request = pageSecurityCheck;
+ logMsg("Sending request \"" + request
+ + "\" with login information (as " + username + ").");
+ Properties postData = new Properties();
+ postData.setProperty("j_username", username);
+ postData.setProperty("j_password", password);
+ response = WebUtil.sendRequest("POST", InetAddress.getByName(hostname),
+ portnum, request, postData, cookies);
+
+ // Check that the page was found (no error).
+ if (response.isError()) {
+ logErr("Could not find " + request);
+ throw new Exception("test6 failed.");
+ }
+
+ // Call followRedirect() to make sure we receive the required page
+ response = followRedirect(response, 6);
+
+ // Check to make sure we are authenticated by checking the page
+ // content. The jsp should output "The user principal is: j2ee"
+ String searchString = searchFor + username;
+ if (response.content.indexOf(searchString) == -1) {
+ logErr("User Principal incorrect. Page received:");
+ logErr(response.content);
+ logErr("(Should say: \"" + searchString + "\")");
+ throw new Exception("test6 failed.");
+ }
+ logMsg("User Principal correct.");
+
+ // Check to make sure isUserInRole is working properly:
+ Hashtable roleCheck = new Hashtable();
+ roleCheck.put("ADM", Boolean.FALSE);
+ roleCheck.put("MGR", Boolean.TRUE);
+ roleCheck.put("VP", Boolean.FALSE);
+ roleCheck.put("EMP", Boolean.TRUE);
+ // roleCheck.put( "Manager", new Boolean( false ) );
+ if (!checkRoles(response.content, roleCheck)) {
+ logErr("isUserInRole() does not work correctly.");
+ logErr("Page Received:");
+ logErr(response.content);
+ throw new Exception("test6 failed.");
+ }
+ logMsg("isUserInRole() correct.");
+
+ } catch (Exception e) {
+ logErr("Caught exception: " + e.getMessage());
+ e.printStackTrace();
+ throw new Exception("test6 failed: ", e);
+ }
+ }
+
+ /*
+ * testName: test7
+ *
+ * @assertion: Servlet Specification v2.3, sec 9.4 A special directory exists
+ * within the application hierarchy named WEB-INF. This directory contains all
+ * things related to the application that aren't in the document root of the
+ * application. It is important to note that the WEB-INF node is not part of
+ * the public document tree of the application. No file contained in the
+ * WEB-INF directory may be served directly to a client.
+ *
+ * @test_Strategy: 1) send a http request to WEB-INF directory 2) expect 404
+ * or 403 3) repeat step 1 and 2 for the following a) web-inf (for case
+ * insensitive platforms) b) WEB-INF/web.xml c) web-inf/web.xml 4) based on
+ * the http return code report test status
+ */
+
+ public void test7() throws Exception {
+ List statusCodes;
+
+ try {
+ // Try accessing WEB-INF
+ request = pageBase + "/WEB-INF/";
+
+ statusCodes = new ArrayList();
+ statusCodes.add("404");
+ statusCodes.add("403");
+
+ this.testStatusCodes(request, statusCodes, "test7");
+
+ // Try accessing /web-inf (for case insensitive platforms)
+ request = pageBase + "/web-inf/";
+
+ statusCodes = new ArrayList();
+ statusCodes.add("404");
+ statusCodes.add("403");
+
+ this.testStatusCodes(request, statusCodes, "test7");
+
+ // Try accessing WEB-INF/web.xml
+ request = pageBase + "/WEB-INF/web.xml";
+
+ statusCodes = new ArrayList();
+ statusCodes.add("404");
+
+ this.testStatusCodes(request, statusCodes, "test7");
+
+ // Try accessing web-inf/web.xml (for case insensitive platforms)
+ request = pageBase + "/web-inf/web.xml";
+
+ statusCodes = new ArrayList();
+ statusCodes.add("404");
+
+ this.testStatusCodes(request, statusCodes, "test7");
+
+ // Try accessing WEB-INF/web.xml
+ request = pageBase + "/WEB-INF/web.xml";
+
+ statusCodes = new ArrayList();
+ statusCodes.add("404");
+
+ this.testStatusCodes(request, statusCodes, "test7");
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ /*
+ * testName: test8
+ *
+ * @assertion: Servlet Specification v2.3, sec 9.5 Web applications can be
+ * packaged and signed, using the standard Java Archive tools, into a Web
+ * ARchive format (war) file. When packaged into such a form, a META-INF
+ * directory will be present which contains information useful to the Java
+ * Archive tools. If this directory is present, the servlet container must not
+ * allow it be served as content to a web client's request.
+ *
+ * @test_Strategy: 1) send a http request to META-INF directory 2) expect 404
+ * or a 403 3) repeat step 1 and 2 for the following a) meta-inf (for case
+ * insensitive platforms) b) META-INF/MANIFEST.MF c) meta-inf/manifest.mf 4)
+ * based on the http return code, report test status
+ */
+
+ public void test8() throws Exception {
+ try {
+
+ // Try accessing META-INF
+ request = pageBase + "/META-INF/";
+ logMsg("Sending request \"" + request + "\"");
+ response = WebUtil.sendRequest("GET", InetAddress.getByName(hostname),
+ portnum, request, null, null);
+
+ // Call followRedirect() to make sure we receive the required page
+ response = followRedirect(response, 8);
+
+ // Receive "404" or "403" error code.
+ if (response.statusToken.equals("404")
+ || response.statusToken.equals("403")) {
+ logMsg("Status Token " + response.statusToken);
+ logMsg("Received expected error code");
+ } else {
+ logErr("Did not receive expected error code" + request);
+ logMsg("Status Token " + response.statusToken);
+ logErr("Page content:");
+ logErr(response.content);
+ throw new Exception("test8 failed.");
+ }
+
+ // Try accessing /meta-inf (for case insensitive platforms)
+ request = pageBase + "/meta-inf/";
+ logMsg("Sending request \"" + request + "\"");
+ response = WebUtil.sendRequest("GET", InetAddress.getByName(hostname),
+ portnum, request, null, null);
+
+ // Call followRedirect() to make sure we receive the required page
+ response = followRedirect(response, 8);
+
+ // Receive "404" or "403" error code.
+ if (response.statusToken.equals("404")
+ || response.statusToken.equals("403")) {
+ logMsg("Status Token " + response.statusToken);
+ logMsg("Received expected error code");
+ } else {
+ logErr("Did not receive expected error code" + request);
+ logMsg("Status Token " + response.statusToken);
+ logErr("Page content:");
+ logErr(response.content);
+ throw new Exception("test8 failed.");
+ }
+
+ // Try accessing META-INF/MANIFEST.MF
+ request = pageBase + "/META-INF/MANIFEST.MF";
+ logMsg("Sending request \"" + request + "\"");
+ response = WebUtil.sendRequest("GET", InetAddress.getByName(hostname),
+ portnum, request, null, null);
+
+ // Call followRedirect() to make sure we receive the required page
+ response = followRedirect(response, 8);
+
+ // Receive "404" or "403" error code.
+ if (response.statusToken.equals("404")
+ || response.statusToken.equals("403")) {
+ logMsg("Status Token " + response.statusToken);
+ logMsg("Received expected error code");
+ } else {
+ logErr("Did not receive expected error code" + request);
+ logMsg("Status Token " + response.statusToken);
+ logErr("Page content:");
+ logErr(response.content);
+ throw new Exception("test8 failed.");
+ }
+
+ // Try accessing meta-inf/manifest.mf(for case insensitive platforms)
+ request = pageBase + "/meta-inf/manifest.mf";
+ logMsg("Sending request \"" + request + "\"");
+ response = WebUtil.sendRequest("GET", InetAddress.getByName(hostname),
+ portnum, request, null, null);
+
+ // Call followRedirect() to make sure we receive the required page
+ response = followRedirect(response, 8);
+
+ // Receive "404" or "403" error code.
+ if (response.statusToken.equals("404")
+ || response.statusToken.equals("403")) {
+ logMsg("Status Token " + response.statusToken);
+ logMsg("Received expected error code");
+ } else {
+ logErr("Did not receive expected error code" + request);
+ logMsg("Status Token " + response.statusToken);
+ logErr("Page content:");
+ logErr(response.content);
+ throw new Exception("test8 failed.");
+ }
+
+ } catch (Exception e) {
+ logErr("Caught exception: " + e.getMessage());
+ e.printStackTrace();
+ throw new Exception("test8 failed: ", e);
+ }
+ }
+
+ /*
+ * testName: test9
+ *
+ * @assertion: URLMapping from Servlet Specification v2.3, sec 11.2
+ *
+ * 1) A string beginning with a / character and ending with a /* postfix is
+ * used as a path mapping. 2) A string beginning with a *. prefix is used as
+ * an extension mapping. 3) All other strings are used as exact matches only
+ * 4) A string containing only the / character indicates that servlet
+ * specified by the mapping becomes the "deException" servlet of the application.
+ * In this case the servlet path is the request URI minus the context path and
+ * the path info is null.
+ *
+ *
+ * @test_Strategy: 1) Deploy a two webcomponents One.jsp and Two.jsp
+ * exercising various mapping rules 2) Make a http request with a URL(based on
+ * the above mapping rules) 3) Make a http request with a absolute match URL.
+ * 4) compare the results obtained through step 2 and 3 and declare test
+ * result
+ *
+ */
+
+ public void test9() throws Exception {
+ try {
+ String testURL = null;
+ String exactMatchURL = null;
+
+ // This tests exercises the URL mapping rules
+ // See compareURLContents() method description for more info
+
+ // Note: pageOne can be a JSP or Servlet
+ // 1) for JSP
+ // pageOne = pageBase + "/One.jsp";
+ // 2) for servlet
+ // pageOne = pageBase + "/OneTest";
+
+ // Try accessing pageOne using "/One/index.html"
+ testURL = pageBase + "/One/index.html";
+ exactMatchURL = pageOne;
+ compareURLContents(testURL, 9, exactMatchURL);
+
+ // Try accessing pageOne using "/One/*"
+ testURL = pageBase + "/One/*";
+ exactMatchURL = pageOne;
+ compareURLContents(testURL, 9, exactMatchURL);
+
+ // Note: pageTwo can be a JSP or Servlet
+ // 1) for JSP
+ // pageTwo = pageBase + "/Two.jsp";
+ // 2) for servlet
+ // pageTwo = pageBase + "/TwoTest";
+
+ // Try accessing pageTwo using "*.jsp"
+ testURL = pageBase + "/*.jsp";
+ exactMatchURL = pageTwo;
+ compareURLContents(testURL, 9, exactMatchURL);
+
+ // Try accessing pageTwo using "*.two"
+ testURL = pageBase + "/*.two";
+ exactMatchURL = pageTwo;
+ compareURLContents(testURL, 9, exactMatchURL);
+
+ } catch (Exception e) {
+ logErr("Caught exception: " + e.getMessage());
+ e.printStackTrace();
+ throw new Exception("test9 failed: ", e);
+ }
+ }
+
+ /*
+ * testName: test10
+ *
+ * @assertion: Test isUserInRole(), specified in the Java Servlet
+ * Specification v2.3, Sec 12.3.
+ *
+ * The isUserInRole method expets a String rolename. In order that this
+ * rolename can be adjusted by the application assembler, or the deployer
+ * without having to recompile the Servlet making the call a
+ * element should be declared in the deployment descriptor
+ * with the sub-element containing the rolename passed into this
+ * call. The value of the sub-element is the of the
+ * that the programmer is testing that the caller is mapped to
+ * or not. The container is required to respect this mapping of
+ * to in this manner when determining the
+ * return value of the call.
+ *
+ * If, however, no has been declared with that
+ * matches the argument to isUserInRole, the container must deException to
+ * checking the argument against the list of s for this web
+ * application to determine whether the caller is mapped to the rolename
+ * passed in.
+ *
+ * @test_Strategy: Note: test5 and test6 verifies the first part of the
+ * assertion. This test verifies only the second part of this assertion
+ *
+ * 1. Send request to access Sample.jsp 2. Receive login page(make sure it is
+ * the expected login page) 3. Send form response with username and password
+ * 4. Receive Sample.jsp (ensure principal is correct, and ensure
+ * getRemoteUser() returns the username, and ensure isUserInRole() is working
+ * properly)
+ */
+
+ public void test10() throws Exception {
+ try {
+ requestAndGetLoginPage(pageSample, 10);
+
+ // Send response to login form with session id cookie:
+ request = pageSecurityCheck;
+ logMsg(
+ "Sending request \"" + request + "\" with login information.");
+ Properties postData = new Properties();
+ postData.setProperty("j_username", username);
+ postData.setProperty("j_password", password);
+ response = WebUtil.sendRequest("POST", InetAddress.getByName(hostname),
+ portnum, request, postData, cookies);
+
+ // Check that the page was found (no error).
+ if (response.isError()) {
+ logErr("Could not find " + request);
+ throw new Exception("test10 failed.");
+ }
+
+ // Call followRedirect() to make sure we receive the required page
+ response = followRedirect(response, 10);
+
+ // Check to make sure we are authenticated by checking the page
+ // content. The jsp should output "The user principal is: j2ee"
+ String searchString = searchFor + username;
+ if (response.content.indexOf(searchString) == -1) {
+ logErr("User Principal incorrect. Page received:");
+ logErr(response.content);
+ logErr("(Should say: \"" + searchString + "\")");
+ throw new Exception("test10 failed.");
+ }
+ logMsg("User Principal correct.");
+
+ // Check to make sure getRemoteUser returns the user name.
+ searchString = searchForGetRemoteUser + username;
+ if (response.content.indexOf(searchString) == -1) {
+ logErr("getRemoteUser() did not return " + username + ":");
+ logErr(response.content);
+ logErr("(Should say: \"" + searchString + "\")");
+ throw new Exception("test10 failed.");
+ }
+ logMsg("getRemoteUser() correct.");
+
+ // Check to make sure isUserInRole is working properly:
+ Hashtable roleCheck = new Hashtable();
+ roleCheck.put("Administrator", Boolean.TRUE);
+ if (!checkRoles(response.content, roleCheck)) {
+ logErr("isUserInRole() does not work correctly.");
+ logErr("Page Received:");
+ logErr(response.content);
+ throw new Exception("test10 failed.");
+ }
+ logMsg("isUserInRole() correct.");
+
+ } catch (Exception e) {
+ logErr("Caught exception: " + e.getMessage());
+ e.printStackTrace();
+ throw new Exception("test10 failed: ", e);
+ }
+ }
+
+ /*
+ * testName: test11
+ *
+ * @assertion: Servlet Specification v2.3, sec 13.2 DTD The auth-constraint
+ * element indicates the user roles that should be permitted access to this
+ * resource collection. The role used here must either in a security-role-ref
+ * element, or be the specially reserved role-name * that is a compact syntax
+ * for indicating all roles in the web application. If both * and rolenames
+ * appear, the container interprets this as all roles.
+ *
+ * @test_Strategy: Configure allRoles.jsp to be accessible by allRoles (*)
+ *
+ * 1) Try accesing allRoles.jsp as the following user a) j2ee b) javajoe 2)
+ * Based on the http reply, report test status
+ *
+ *
+ */
+
+ public void test11() throws Exception {
+ try {
+
+ // Access allRoles.jsp as user "j2ee"
+ logMsg("\nAccessing allRoles.jsp as user j2ee");
+ requestAndGetLoginPage(pageallRoles, 11);
+ request = pageSecurityCheck;
+ logMsg(
+ "Sending request \"" + request + "\" with login information.");
+ Properties postData = new Properties();
+ postData.setProperty("j_username", username);
+ postData.setProperty("j_password", password);
+ response = WebUtil.sendRequest("POST", InetAddress.getByName(hostname),
+ portnum, request, postData, cookies);
+
+ // Check that the page was found (no error).
+ if (response.isError()) {
+ logErr("Could not find " + request);
+ throw new Exception("test11 failed.");
+ }
+
+ // Call followRedirect() to make sure we receive the required page
+ response = followRedirect(response, 11);
+ logMsg("Successfully accessed allRoles.jsp as user j2ee");
+
+ // Access allRoles.jsp as user "javajoe"
+ logMsg("\nAccessing allRoles.jsp as user javajoe");
+ requestAndGetLoginPage(pageallRoles, 11);
+ request = pageSecurityCheck;
+ logMsg(
+ "Sending request \"" + request + "\" with login information.");
+ postData = new Properties();
+ postData.setProperty("j_username", unauthUsername);
+ postData.setProperty("j_password", unauthPassword);
+ response = WebUtil.sendRequest("POST", InetAddress.getByName(hostname),
+ portnum, request, postData, cookies);
+
+ // Check that the page was found (no error).
+ if (response.isError()) {
+ logErr("Could not find " + request);
+ throw new Exception("test11 failed.");
+ }
+
+ // Call followRedirect() to make sure we receive the required page
+ response = followRedirect(response, 11);
+
+ logMsg("Successfully accessed allRoles.jsp as user javajoe");
+
+ } catch (Exception e) {
+ logErr("Caught exception: " + e.getMessage());
+ e.printStackTrace();
+ throw new Exception("test11 failed: ", e);
+ }
+ }
+
+ /*
+ * testName: test12
+ *
+ * @assertion: Servlet Specification v2.3, sec 13.2 (DTD) The
+ * web-resource-collection element is used to identify a subset of the
+ * resources and HTTP methods on those resources within a web application to
+ * which a security constraint applies. If no HTTP methods are specified, then
+ * the security constraint applies to all HTTP methods.
+ *
+ * @test_Strategy: 1) Do not specify any HTTP methods in the security
+ * constraints of Sample.jsp
+ *
+ * 2) Access Sample.jsp using HTTP methods GET, HEAD, POST, DELETE and PUT.
+ *
+ * 3) If Sample.jsp is accessible with all of the above HTTP methods then
+ * declare test successfull otherwise report test failure
+ *
+ * Note: test12 is ONLY for JSP Area
+ *
+ */
+
+ public void test12() throws Exception {
+ try {
+ // Access Sample.jsp using HTTP method POST
+ logMsg("\nAccessing pageSample Using HTTP method POST");
+ requestAndGetLoginPage(pageSample, 12);
+ request = pageSecurityCheck;
+ logMsg(
+ "Sending request \"" + request + "\" with login information.");
+ Properties postData = new Properties();
+ postData.setProperty("j_username", username);
+ postData.setProperty("j_password", password);
+ response = WebUtil.sendRequest("POST", InetAddress.getByName(hostname),
+ portnum, request, postData, cookies);
+
+ // Check that the page was found (no error).
+ if (response.isError()) {
+ logErr("Could not find " + request);
+ throw new Exception("test12 failed.");
+ }
+
+ // Call followRedirect() to make sure we receive the required page
+ response = followRedirect(response, 12);
+
+ logMsg("response.content :" + response.content);
+ logMsg("Successfully accessed " + pageSample + " with \"POST\"");
+
+ // Change the request to pageSample
+ request = pageSample;
+
+ // Access pageSample using HTTP method GET
+ logMsg("\nAccessing pageSample Using HTTP method GET");
+ response = WebUtil.sendRequest("GET", InetAddress.getByName(hostname),
+ portnum, request, postData, cookies);
+
+ // Check that the page was found (no error).
+ if (response.isError()) {
+ logErr("Could not find " + request);
+ throw new Exception("test12 failed.");
+ }
+
+ // Call followRedirect() to make sure we receive the required page
+ response = followRedirect(response, 12);
+
+ logMsg("response.content :" + response.content);
+ logMsg("Successfully accessed " + pageSample + " with \"GET\"");
+
+ // Access pageSample using HTTP method HEAD
+ logMsg("\nAccessing pageSample Using HTTP method HEAD");
+ response = WebUtil.sendRequest("HEAD", InetAddress.getByName(hostname),
+ portnum, request, postData, cookies);
+
+ // Check that the page was found (no error).
+ if (response.isError()) {
+ logErr("Could not find " + request);
+ throw new Exception("test12 failed.");
+ }
+
+ // Call followRedirect() to make sure we receive the required page
+ response = followRedirect(response, 12);
+
+ logMsg("response.content :" + response.content);
+
+ logMsg("Successfully accessed " + pageSample + " with \"HEAD\"");
+
+ // Read the contents of Sample.jsp and
+ // upload it using HTTP method PUT
+// FileInputStream fstream = new FileInputStream(
+// tshome + "/src/web/jsp/sec/secform/Sample.jsp");
+
+ InputStream fstream =
+ Thread.currentThread().getContextClassLoader().getResourceAsStream("sec/secform/Sample.jsp");
+
+ int fileContentLength = fstream.available();
+ byte[] byteArray = new byte[1024];
+ int bytesRead = fstream.read(byteArray, 0, fileContentLength);
+
+ // Now use HTTP method DELETE and later use http method PUT
+
+ // Delete pageSample using HTTP method DELETE
+ logMsg("\nDELETE " + pageSample + " Using HTTP method DELETE ....");
+ response = WebUtil.sendRequest("DELETE", InetAddress.getByName(hostname),
+ portnum, request, postData, cookies);
+
+ addNewCookies(cookies, response.cookies);
+
+ // Check that the page was found (no error).
+ if (response.isError()) {
+ logErr("Could not find " + request);
+ throw new Exception("test12 failed.");
+ }
+ logMsg("response.content :" + response.content);
+ logMsg("Successfully accessed " + pageSample + " with \"DELETE\"");
+
+ // put pageSample using HTTP method PUT
+ logMsg("\nPUT " + pageSample + " Using HTTP method PUT ....");
+
+ response = uploadUsingHttpMethodPUT("PUT",
+ InetAddress.getByName(hostname), portnum, request,
+ byteArray, cookies, username, password);
+
+ // Check that the page was found (no error).
+ if (response.isError()) {
+ logErr("Could not find " + request);
+ throw new Exception("test12 failed.");
+ }
+ logMsg("response.content :" + response.content);
+ logMsg("response.statusToken :" + response.statusToken);
+ logMsg("uploaded " + pageSample + "using HTTP method PUT");
+
+ } catch (Exception e) {
+ logErr("Caught exception: " + e.getMessage());
+ e.printStackTrace();
+ throw new Exception("test12 failed: ", e);
+ }
+ }
+
+ /*
+ * testName: test13
+ *
+ * @assertion: Servlet Specification v2.3, sec 12.2 The security model does
+ * not apply when a servlet uses the RequestDispatcher to invoke a static
+ * resource or servlet using a forward or an include.
+ *
+ *
+ * @test_Strategy:
+ *
+ * 1) Configure two servlets (IncludedServlet and ForwardedServlet) to be
+ * accessible only by administrator.
+ *
+ * 2) Configure ControlServlet to be accessible by everyone (i.e no security
+ * constraints for ControlServlet)
+ *
+ * 3) Now as a unauthenticated user access ForwardedServlet and
+ * IncludedServlet from ControlServlet
+ *
+ * ControlServlet ===>ForwardedServlet===>IncludedServlet
+ *
+ * i.e 3.1) From a ControlServlet access ForwardedServlet through dispatcher's
+ * forward method.
+ *
+ * 3.2) From the ForwardedServlet access/include IncludedServlet through
+ * Request dispatcher's include method
+ *
+ * 4) If the servlets(ForwardedServlet and IncludedServlet) are accessible
+ * report the test success otherwise report test failure
+ *
+ * Note: test13 is ONLY for SERVLET Area
+ *
+ */
+
+ public void test13() throws Exception {
+ try {
+
+ request = pageServletBase + "/ControlServlet";
+
+ // Access ControlServlet"
+ logMsg("\nAccessing ControlServlet");
+ logMsg("Sending request " + request);
+ response = WebUtil.sendRequest("POST", InetAddress.getByName(hostname),
+ portnum, request, null, null);
+ logMsg("response.content 1:" + response.content);
+
+ // Check that the page was found (no error).
+ if (response.isError()) {
+ logErr("Could not find " + request);
+ throw new Exception("test13 failed.");
+ }
+
+ // Call followRedirect() to make sure we receive the required page
+ response = followRedirect(response, 13);
+ logMsg("response.content 2:" + response.content);
+ logMsg("Successfully accessed ControlServlet,"
+ + " ForwardedServlet and IncludedServlet");
+
+ } catch (Exception e) {
+ logErr("Caught exception: " + e.getMessage());
+ e.printStackTrace();
+ throw new Exception("test13 failed: ", e);
+ }
+ }
+
+ /*
+ * testName: test14
+ *
+ * @assertion: Test FORM-based authentication, specified in the Java Servlet
+ * Specification v2.3, Sec 12.6
+ *
+ * Therefore, a servlet container is required to track authentication
+ * information at the container level (rather than at the web application
+ * level). This allows users authenticated for one web application to access
+ * other resources managed by the container permitted to the same security
+ * identity.
+ *
+ * @test_Strategy: 1. Configure pageSec(jspSec.jsp or ServletSecTest) and
+ * pageSample(Sample.jsp or SampleTest ) to be accessible only by
+ * Administrator 2. Send request to access jspSec.jsp 3. Receive login page 4.
+ * Send form response with username and password 5. Receive jspSec.jsp (ensure
+ * principal is correct, and ensure getRemoteUser() returns the username, and
+ * ensure isUserInRole() is working properly) 6. Try accessing
+ * pageSample(Sample.jsp or SampleTest) which is also configured to be
+ * accessible with the same security identity, since we are already
+ * authenticated we should be able to access pageSample without going through
+ * login page again. 7. Ensure principal is still correct and getRemoteUser()
+ * still returns the correct username. Also ensure isUserInRole() is still
+ * working properly.
+ */
+
+ public void test14() throws Exception {
+ try {
+ logMsg("\nAccessing pageSec: " + pageSec);
+ requestAndGetLoginPage(pageSec, 14);
+
+ // Send response to login form with session id cookie:
+ request = pageSecurityCheck;
+ logMsg(
+ "Sending request \"" + request + "\" with login information.");
+ Properties postData = new Properties();
+ postData.setProperty("j_username", username);
+ postData.setProperty("j_password", password);
+ response = WebUtil.sendRequest("POST", InetAddress.getByName(hostname),
+ portnum, request, postData, cookies);
+
+ // Check that the page was found (no error).
+ if (response.isError()) {
+ logErr("Could not find " + request);
+ throw new Exception("test14 failed.");
+ }
+
+ // Call followRedirect() to make sure we receive the required page
+ response = followRedirect(response, 14);
+
+ // Check to make sure we are authenticated by checking the page
+ // content. The jsp should output "The user principal is: j2ee"
+ String searchString = searchFor + username;
+ if (response.content.indexOf(searchString) == -1) {
+ logErr("User Principal incorrect. Page received:");
+ logErr(response.content);
+ logErr("(Should say: \"" + searchString + "\")");
+ throw new Exception("test14 failed.");
+ }
+ logMsg("User Principal correct.");
+
+ // Check to make sure getRemoteUser returns the user name.
+ searchString = searchForGetRemoteUser + username;
+ if (response.content.indexOf(searchString) == -1) {
+ logErr("getRemoteUser() did not return " + username + ":");
+ logErr(response.content);
+ logErr("(Should say: \"" + searchString + "\")");
+ throw new Exception("test1 failed.");
+ }
+ logMsg("getRemoteUser() correct.");
+
+ // Check to make sure isUserInRole is working properly:
+ Hashtable roleCheck = new Hashtable();
+ roleCheck.put("ADM", Boolean.TRUE);
+ roleCheck.put("MGR", Boolean.FALSE);
+ roleCheck.put("VP", Boolean.FALSE);
+ roleCheck.put("EMP", Boolean.TRUE);
+ // roleCheck.put( "Administrator", new Boolean( false ) );
+ if (!checkRoles(response.content, roleCheck)) {
+ logErr("isUserInRole() does not work correctly.");
+ logErr("Page Received:");
+ logErr(response.content);
+ throw new Exception("test14 failed.");
+ }
+ logMsg("isUserInRole() correct.");
+
+ // Now that we are authenticated, try accessing pageSample
+ // without going through the login page again.
+ request = pageSample;
+ logMsg("\nAccessing pageSample :" + request);
+ response = WebUtil.sendRequest("GET", InetAddress.getByName(hostname),
+ portnum, request, null, cookies);
+
+ // Check that the page was found (no error).
+ if (response.isError()) {
+ logErr("Could not find " + pageSec);
+ throw new Exception("test14 failed.");
+ }
+
+ // Check to make sure we are still authenticated.
+ if (response.content.indexOf(searchString) == -1) {
+ logErr("User Principal incorrect. Page received:");
+ logErr(response.content);
+ logErr("(Should say: \"" + searchString + "\")");
+ throw new Exception("test14 failed.");
+ }
+ logMsg("User Principal still correct.");
+
+ // Check to make sure getRemoteUser still returns the user name.
+ searchString = searchForGetRemoteUser + username;
+ if (response.content.indexOf(searchString) == -1) {
+ logErr("getRemoteUser() did not return " + username
+ + " after lazy authentication:");
+ logErr(response.content);
+ logErr("(Should say: \"" + searchString + "\")");
+ throw new Exception("test14 failed.");
+ }
+ logMsg("getRemoteUser() still correct.");
+
+ } catch (Exception e) {
+ logErr("Caught exception: " + e.getMessage());
+ e.printStackTrace();
+ throw new Exception("test14 failed: ", e);
+ }
+ }
+
+ /*
+ * testName: test15
+ *
+ * @assertion: Test FORM-based authentication, specified in the Java Servlet
+ * Specification v2.3, Sec 12.6
+ *
+ * This is similar to test14 except this is validating that we can not bypass
+ * security constraints when sso is on by simply adding "/j_security_check" to
+ * the request url. By adding "j_security_check" to the end of a request but
+ * not specifying authN creds, we should NOT be redirected to the
+ * requested/restricted page as we have not yet authenticated (even though we
+ * tried to trick/confuse the system by appending 'j_security_check' onto our
+ * request.)
+ *
+ * @test_Strategy: 1. attempt to access a protected resource by: Sending a
+ * request to access url: "/j_security_check" 2. We should not be
+ * authenticated yet so should get a response back from server with either an
+ * error or login form (we must verify that we are not authenticated and that
+ * we did NOT get the requested(and restricted) form back from server.
+ *
+ */
+
+ public void test15() throws Exception {
+
+ String modifiedPageSec = pageSec + pageSecurityCheck;
+ try {
+ // 1. attempt to access a protected resource
+ TestUtil.logTrace("Sending request \"" + modifiedPageSec + "\"");
+ try {
+ response = WebUtil.sendRequest("GET", InetAddress.getByName(hostname),
+ portnum, modifiedPageSec, null, null);
+ } catch (Exception ex) {
+ // if here, problem as we should have been redirected
+ logErr(
+ "ERROR - got exception when trying to access restricted page w/out AuthN first.");
+ ex.printStackTrace();
+ throw new Exception("test15 failed.");
+ }
+
+ if (response != null) {
+ // if we got directed to login page that is okay too
+ TestUtil.logTrace("response.content=" + response.content);
+
+ // 2. verify that the requested page was NOT accessed/found
+ String searchString = "getAuthType()"; // this string appears on the
+ // pageSec page
+ if (response.content.indexOf(searchString) != -1) {
+ // Error - it looks like we were able to access the requested page!
+ String err = "Error - we were not authenticated but were able to access the ";
+ err += "following page: " + modifiedPageSec
+ + " with a return status = " + response.statusToken;
+ logErr(err);
+ logErr("response.content = " + response.content);
+ throw new Exception("test15 failed.");
+ } else {
+ TestUtil.logTrace(
+ "Good - we were not able to access restricted page without authenticating.");
+ }
+ } else {
+ TestUtil.logTrace("response=null");
+ }
+
+ logMsg("test15 passed.");
+
+ } catch (Exception e) {
+ logErr("Caught exception: " + e.getMessage());
+ e.printStackTrace();
+ throw new Exception("test15 failed: ", e);
+ }
+ }
+
+ /*
+ * testName: test16
+ *
+ * @assertion: Test ability to login via the HttpServletRequst.login() method.
+ * as specified in the Java Servlet Specification v3.1, Sec 13.3
+ *
+ * If user has not been authenticated and user attempts to access an
+ * unprotected web resource, the user should be able to access it. Since the
+ * user was not authenticated, calls to getUserPrincipal() should not return
+ * the name of user "j2ee" since. Once in the servlet, we should be able to
+ * invoke the HttpServletRequest.login() call to authenticate user "j2ee" and
+ * then calls to getUserPrincipal() should return user "j2ee"
+ *
+ *
+ * @test_Strategy: 1. Send request to access ServletProgrammaticLogin 2. the
+ * servlet performs tasks and sends response data back 3. we parse the data to
+ * see if we got desired output
+ */
+
+ public void test16() throws Exception {
+ try {
+
+ // Send request to ProgrammaticLogin servlet and include username
+ // and password for use within servlet
+ request = pageProgLogin;
+
+ // set some params that will be needed from within the pageProgLogin
+ // servlet
+ Properties postData = new Properties();
+ TestUtil.logTrace("setting request parameter my_username = " + username);
+ TestUtil.logTrace("setting request parameter my_password = " + password);
+ postData.setProperty("the_username", username);
+ postData.setProperty("the_password", password);
+
+ logMsg("Sending request " + request);
+ response = WebUtil.sendRequest("POST", InetAddress.getByName(hostname),
+ portnum, request, postData, cookies);
+
+ TestUtil.logTrace("response.content = \n" + response.content);
+
+ if (!response.statusToken.equals("200")) {
+ logErr(
+ "ERROR: not able to do Programmatic Login in: " + pageProgLogin);
+ throw new Exception("test16 failed.");
+ }
+
+ // Check that we did not receive an error
+ if (response.isError()) {
+ logErr("Error retrieving " + request);
+ throw new Exception("test16 failed.");
+ }
+
+ TestUtil.logTrace(response.content); // debug aid
+
+ // verify there were no errors detected fom within our servlet
+ String searchString = "ERROR - HttpServletRequest.login";
+ if (response.content.indexOf(searchString) != -1) {
+ logErr(response.content);
+ throw new Exception("test16 failed.");
+ }
+
+ // verify that we got success
+ searchString = "HttpServletRequest.login() passed";
+ if (response.content.indexOf(searchString) == -1) {
+ logErr(response.content);
+ throw new Exception("test16 failed.");
+ }
+
+ logMsg("test16 passed.");
+
+ } catch (Exception e) {
+ logErr("Caught exception: " + e.getMessage());
+ e.printStackTrace();
+ throw new Exception("test16 failed: ", e);
+ }
+ }
+
+ /*
+ * testName: test17
+ *
+ * @assertion: Test FORM-based authentication, specified in the Java Servlet
+ * Specification v2.2, Sec 11.5.3.
+ *
+ * If user has been authenticated and user attempts to access a protected web
+ * resource, and user enters correct username and password of a user that is
+ * authorized to access the resource, the resource is returned (similar to
+ * test1)
+ *
+ * @test_Strategy: 1. Send request to access protected page (ie.
+ * pageServletProgLogout) 2. Receive login page 3. Send form response with
+ * username(j2ee) and password 4. Receive resource 5. make sure no ERRORs
+ * occurrred on pageServletProgLogout and that it actually did log us out.
+ *
+ */
+
+ public void test17() throws Exception {
+ try {
+ requestAndGetLoginPage(pageServletProgLogout, 1);
+
+ // Send response to login form with session id cookie:
+ request = pageSecurityCheck;
+ logMsg(
+ "Sending request \"" + request + "\" with login information.");
+ Properties postData = new Properties();
+ postData.setProperty("j_username", username);
+ postData.setProperty("j_password", password);
+ response = WebUtil.sendRequest("POST", InetAddress.getByName(hostname),
+ portnum, request, postData, cookies);
+
+ // Check that the page was found (no error).
+ TestUtil.logTrace("response.content = " + response.content); // debug aid
+ if (response.isError()) {
+ logErr("Could not find " + request);
+ throw new Exception("test17 failed.");
+ }
+
+ // Call followRedirect() to make sure we receive the required page
+ response = followRedirect(response, 17);
+ TestUtil.logTrace("response.content = " + response.content); // debug aid
+
+ // Check to make sure we are authenticated by checking the page
+ // content. It should contain the string below to indicate we
+ // properly accessed the servlet.
+ String searchString = "enterred ServletProgrammaticLogout.service()";
+ if (response.content.indexOf(searchString) == -1) {
+ String str = "Error - Did not get expected content from page: "
+ + pageServletProgLogout;
+ str += " Content should have contained: " + searchString;
+ logErr(str);
+ throw new Exception("test17 failed.");
+ }
+
+ // now make sure we didnt get any errors in our content
+ String errString = "ERROR - HttpServletRequest.logout()";
+ if (response.content.indexOf(errString) != -1) {
+ // there was an error msg detected in servlet content
+ String str = "Error - returned in content from page: "
+ + pageServletProgLogout;
+ logErr(str);
+ throw new Exception("test17 failed.");
+ }
+ logMsg("test17 passed.");
+
+ } catch (Exception e) {
+ logErr("Caught exception: " + e.getMessage());
+ e.printStackTrace();
+ throw new Exception("test17 failed: ", e);
+ }
+ }
+
+ /*
+ * testName: test18
+ *
+ * @assertion: Test ability to authenticate using
+ * HttpServletRequst.authenticate() as specified in the Java Servlet
+ * Specification v3.1, Sec 13.3
+ *
+ * If user has not been authenticated and user attempts to access an
+ * unprotected web resource, the user should be able to access it. Since the
+ * user was not authenticated, calls to getUserPrincipal() should return null.
+ * Calls to authenticate() should return false. Once in the servlet, we should
+ * be able to invoke the HttpServletRequest.login() call to login with user
+ * "j2ee" and then calls to getUserPrincipal() should return user "j2ee".
+ * Calls to authenticate() should return true.
+ *
+ * @test_Strategy: 1. Send request to access ServletProgrammaticLogin 2. the
+ * servlet performs tasks and sends response data back 3. we parse the data to
+ * see if we got desired output
+ */
+
+ public void test18() throws Exception {
+ try {
+
+ // Send request to ProgrammaticLogin servlet and include username
+ // and password for use within servlet
+ request = pageProgAuthen;
+
+ // set some params that will be needed from within the pageProgLogin
+ // servlet
+ Properties postData = new Properties();
+ postData.setProperty("the_username", username);
+ postData.setProperty("the_password", password);
+
+ logMsg("Sending request " + request);
+ response = WebUtil.sendRequest("POST", InetAddress.getByName(hostname),
+ portnum, request, postData, cookies);
+
+ // Call followRedirect() to make sure we receive the required page
+ TestUtil.logTrace("YYYYY: response.content = \n" + response.content);
+
+ if (!response.statusToken.equals("200")) {
+ logErr(
+ "ERROR: not able to do Programmatic Login in: " + pageProgLogin);
+ throw new Exception("test18 failed.");
+ }
+
+ // Check that we did not receive an error
+ if (response.isError()) {
+ logErr("Error retrieving " + request);
+ throw new Exception("test18 failed.");
+ }
+
+ // verify there were no errors detected fom within our servlet
+ String searchString = "ERROR - HttpServletRequest.authenticate";
+ if (response.content.indexOf(searchString) != -1) {
+ logErr(response.content);
+ throw new Exception("test18 failed.");
+ }
+
+ // now verify the authenticate truely passed
+ if (response.content
+ .indexOf("HttpServletRequest.authenticate passed") == -1) {
+ logErr(response.content);
+ throw new Exception("test18 failed.");
+ }
+
+ logMsg("test18 passed.");
+
+ } catch (Exception e) {
+ logErr("Caught exception: " + e.getMessage());
+ e.printStackTrace();
+ throw new Exception("test18 failed: ", e);
+ }
+ }
+
+ /**
+ * Uploads data from a byteArray to an URL. A WebUtil.Response object is
+ * returned with the response information.
+ *
+ * @param method
+ * http method "PUT"
+ * @param addr
+ * Address of web server
+ * @param port
+ * Port of web server
+ * @param req
+ * The file to request (e.g. /jsp_dep_secContextRoot/jspSec.jsp)
+ * @param postData
+ * is a byteArray which contains the data to be posted
+ * @param cookieList
+ * A list of cookies to send when requesting the page. null if no
+ * cookie list is to be sent.
+ * @param username
+ * The username for authentication, null if no authentication
+ * required.
+ * @param password
+ * The password for authentication, null if no authentication
+ * required.
+ * @return WebUtil.Response object containing response information
+ * @exception IOException
+ * Thrown if request could not be made
+ */
+ public static Response uploadUsingHttpMethodPUT(String method,
+ InetAddress addr, int port, String req, byte[] postData,
+ Hashtable cookieList, String username, String password)
+ throws IOException {
+ String protocol = "HTTP/1.0";
+ URL requestURL;
+ Socket socket = null;
+ PrintWriter out = null;
+ BufferedReader in = null;
+ String line;
+ Response response = new Response();
+
+ try {
+ requestURL = new URL("http", addr.getHostName(), port, req);
+ req = method + " " + req + " " + protocol;
+
+ socket = new Socket(addr, port);
+
+ in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
+ out = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()));
+ out.println(req);
+
+ if (cookieList != null) {
+ // Send cookies:
+ Enumeration keys = cookieList.keys();
+
+ // Does at least one cookie exist?
+ if (keys.hasMoreElements()) {
+ String cookieString = "Cookie: ";
+
+ // Add each cookie to the string
+ boolean first = true;
+ while (keys.hasMoreElements()) {
+ String key = (String) keys.nextElement();
+ String value = (String) cookieList.get(key);
+ cookieString += (first ? "" : "; ") + key + "=" + value; // + ";
+ // $Path=/";
+ first = false;
+ }
+
+ // Write cookies:
+ out.println(cookieString);
+ }
+ }
+
+ // Send authentication information if necessary:
+ if (username != null) {
+ String code = WebUtil.encodeBase64(username + ":" + password);
+ out.println("Authorization: Basic " + code.trim());
+ }
+
+ // Send extra header information if we are posting.
+ if (postData != null) {
+ out.println("Content-type: text/data");
+ }
+
+ // Read the file contents from the byte array(postData)
+ // and store it in a string(fileContents)
+ StringBuffer content = new StringBuffer(1024);
+ ByteArrayInputStream bais = new ByteArrayInputStream(postData);
+ int c;
+ while ((c = bais.read()) != -1) {
+ content.append((char) c);
+ }
+ String fileContents = content.toString();
+
+ // TestUtil.logMsg("File Content: "+ fileContents);
+
+ // If this is a post request, send post data:
+ if ((postData != null) && method.toUpperCase().equals("PUT")) {
+ String postString = WebUtil.encodeBase64(fileContents);
+
+ // Skip a line:
+ out.println("Content-length: " + postString.length());
+ out.println("");
+ out.println(postString);
+ } else {
+ // Skip a line:
+ out.println("");
+ }
+
+ out.flush();
+
+ // Read first line and check for HTTP version and OK.
+ line = in.readLine();
+ if (line != null) {
+
+ StringTokenizer st = new StringTokenizer(line.trim());
+ response.versionToken = st.nextToken();
+ response.statusToken = st.nextToken();
+ }
+
+ // Read each line of the header until we hit a blank line
+ while ((line = in.readLine()) != null) {
+
+ // Blank line means we are done with the header:
+ if (line.trim().equals("")) {
+ break;
+ }
+
+ // Analyze special tags location and set cookie
+ if (line.toLowerCase().startsWith("location:")) {
+ // This is a redirect. Extract valuable infomration:
+ response.location = line.substring(10);
+ } else if (line.toLowerCase().startsWith("set-cookie:")) {
+ // This is a cookie. Add the cookie to the response
+ // object.
+ response.parseCookie(line);
+ } else if (line.toLowerCase().startsWith("www-authenticate:")) {
+ // Request to authenticate this page.
+ response.authenticationRequested = true;
+ }
+ }
+
+ // The rest is content:
+ while ((line = in.readLine()) != null) {
+ response.content += line + "\n";
+ }
+
+ in.close();
+ out.close();
+ } catch (MalformedURLException e) {
+ throw new IOException("MalformedURLException: " + e.getMessage());
+ } catch (UnknownHostException e) {
+ throw new IOException("UnknownHostException: " + e.getMessage());
+ } catch (ConnectException e) {
+ throw new IOException("ConnectException: " + e.getMessage());
+ }
+
+ return response;
+ }
+
+ /**
+ * Outputs a single line of text to the given output stream. Appends a \r\n
+ * automatically. By adding a System.out.println here, you can easily echo
+ * what is being sent to the web server.
+ */
+ private static void send(PrintWriter out, String s) {
+ out.print(s + "\r\n");
+ }
+
+ /**
+ * Helper method that is used in tests 1, 2 and 3. Performs the following
+ * actions:
+ *
+ * 1. Send request to access passed in url 2. Receive redirect to login page,
+ * extract location and session id cookie 3. Send request to access new
+ * location, send cookie 4. Receive login page
+ *
+ * @param request
+ * The initial page to request
+ * @param testNum
+ * The test number for correct display of error messages.
+ */
+ private void requestAndGetLoginPage(String request, int testNum)
+ throws Exception {
+ // Request restricted jsp page.
+ logMsg("Sending request \"" + request + "\"");
+ response = WebUtil.sendRequest("GET", InetAddress.getByName(hostname),
+ portnum, request, null, null);
+
+ // Check that the page was found (no error).
+ if (response.isError()) {
+ logErr("Could not find " + request);
+ throw new Exception("test" + testNum + " failed.");
+ }
+
+ // if (response.statusToken=302)
+ // then follow redirect to get the login page
+
+ if (response.statusToken.equals("302")) {
+ // We should receive a redirection to the login page:
+ if (response.location == null) {
+ logErr("No redirection to login page received.");
+ throw new Exception("test" + testNum + " failed.");
+ }
+
+ // Extract location from redirection and format new request:
+ request = WebUtil.getRequestFromURL(response.location);
+ logMsg("Redirect to: " + response.location);
+
+ // Extract cookies:
+ cookies = response.cookies;
+
+ logMsg("Before requesting redirected Page:" + "response.content="
+ + response.content);
+
+ // Request redirected page (login page):
+ logMsg("Sending request \"" + request + "\"");
+ response = WebUtil.sendRequest("GET", InetAddress.getByName(hostname),
+ portnum, request, null, cookies);
+
+ // Check that the page was found (no error).
+ if (response.isError()) {
+ logErr("Could not find " + request);
+ throw new Exception("test" + testNum + " failed.");
+ }
+
+ } else {
+ // Extract cookies:
+ cookies = response.cookies;
+ }
+
+ // Because the authentication data is posted on the registered login form,
+ // There is no need to compare login page here.
+ /*
+ * request = pageLogin;
+ *
+ * // Request login page TestUtil.logMsg( "Sending request \"" + request +
+ * "\"" ); loginPageRequestResponse = WebUtil.sendRequest( "GET",
+ * InetAddress.getByName( hostname ), portnum, request,
+ * null, cookies );
+ *
+ * // Check that the page was found (no error). if(
+ * loginPageRequestResponse.isError() ) { TestUtil.logErr( "Could not find "
+ * + request ); throw new Exception( "test" + testNum + " failed." ); }
+ *
+ * //Compare the received login page with the expected login page // i.e
+ * Check whether response.content ==loginPageRequestResponse.content if
+ * (response.content.equals(loginPageRequestResponse.content))
+ * TestUtil.logMsg("Received the expected login form"); else {
+ * TestUtil.logMsg("response.conent\n"+response.content);
+ * TestUtil.logMsg("loginPageRequestResponse.conent\n"+
+ * loginPageRequestResponse.content);
+ * TestUtil.logMsg("Received incorrect login form"); throw new Exception( "test"
+ * + testNum + " failed." ); }
+ */
+
+ }
+
+ /**
+ * Helper method that is used in test 9. Performs the following actions:
+ *
+ * 1. Send request to access a jsp using testURL (for example testURL can be
+ * "/*.jsp") 2. Checks the status of the http reply 3. If the page is not
+ * accessible throw exception 4. If the page is accessible, then compare the
+ * content from the testURL with the contents of exact match URL. i.e compare
+ * 1) TEST URL : http://hostname:port/context_root/*.jsp 2) Exact match URL:
+ * http://hostname:port/context_root/foo.jsp
+ *
+ * Note: Here *.jsp is mapped to foo.jsp
+ *
+ * If the contents are same then the mapping is correct, otherwise throw
+ * exception
+ *
+ * @param testURL
+ * The test URL (for example "/*.jsp")
+ * @param testNum
+ * The test number for correct display of error messages.
+ * @param exactMatchURL
+ * The exact match URL (for example "/foo.jsp")
+ */
+ private void compareURLContents(String testURL, int testNum,
+ String exactMatchURL) throws Exception {
+ // Request a jsp page using testURL.
+ logMsg("Sending request \"" + testURL + "\"");
+ response = WebUtil.sendRequest("GET", InetAddress.getByName(hostname),
+ portnum, testURL, null, null);
+
+ // Check that the page was found (no error).
+ if (response.isError()) {
+ logErr("Could not find " + testURL);
+ throw new Exception("test" + testNum + " failed.");
+ }
+
+ Response response2 = null;
+
+ // Request the jsp page using exactMatchURL.
+ logMsg("Sending request \"" + exactMatchURL + "\"");
+ response2 = WebUtil.sendRequest("GET", InetAddress.getByName(hostname),
+ portnum, exactMatchURL, null, null);
+
+ // Check that the page was found (no error).
+ if (response.isError()) {
+ logErr("Could not find " + exactMatchURL);
+ throw new Exception("test" + testNum + " failed.");
+ }
+
+ logMsg("Comparing contents of " + testURL + " and " + exactMatchURL);
+
+ // compare the contents of testURL and exactMatchURL
+ if (!response.content.equals(response2.content)) {
+ logErr(
+ "MISMATCH in contents of " + testURL + " and " + exactMatchURL);
+ logErr("contents of " + testURL);
+ logErr(response.content);
+ logErr("contents of " + exactMatchURL);
+ logErr(response2.content);
+ throw new Exception("test" + testNum + " failed.");
+ } else {
+ logMsg("Contents MATCH : correct URL mapping\n");
+ }
+
+ }
+
+ /**
+ * Helper method to check that isUserInRole is working correctly. Searches the
+ * given page content for "isUserInRole( x ): !y!" for each x = key in
+ * Hashtable and y = corresponding value in hashtable. If all results are as
+ * expected, returns true, else returns false.
+ */
+ private boolean checkRoles(String content, Hashtable roleCheck) {
+ Enumeration keys = roleCheck.keys();
+ boolean pass = true;
+
+ while (pass && keys.hasMoreElements()) {
+ String key = (String) keys.nextElement();
+ boolean expected = ((Boolean) roleCheck.get(key)).booleanValue();
+
+ String search = "isUserInRole(\"" + key + "\"): !" + expected + "!";
+ String logMsg = "Searching for \"" + search + "\": ";
+
+ if (content.indexOf(search) == -1) {
+ pass = false;
+ logMsg += "NOT FOUND!";
+ } else {
+ logMsg += "found.";
+ }
+
+ logMsg(logMsg);
+ }
+
+ return pass;
+ }
+
+ public void cleanup() throws Exception {
+ logMsg("cleanup");
+ }
+
+ /**
+ * Helper method that is used in tests 1, 2, 3, 5 and 6. Performs the
+ * following actions:
+ *
+ * 1. Checks whether the response.statusToken==302 or 301
+ * if(response.statusToken==302) || (response.statusToken==301) send request
+ * to redirected URL 2. Returns Response object
+ *
+ * @param response
+ * The initial page response
+ * @param testNum
+ * The test number for correct display of error messages.
+ */
+ public Response followRedirect(Response response, int testNum)
+ throws Exception {
+
+ // if (response.statusToken=302)
+ // send request to redirected URL
+ if ((response.statusToken.equals("301"))
+ || (response.statusToken.equals("302"))) {
+ // We should receive a redirection page:
+ if (response.location == null) {
+ logErr("redirection URL : null");
+ throw new Exception("test" + testNum + " failed.");
+ }
+
+ // Extract location from redirection and format new request:
+ request = WebUtil.getRequestFromURL(response.location);
+ logMsg("Redirect to: " + response.location);
+
+ // update cookies if the webserver choose to send cookies,
+ // immediately after a successful http post request.
+ addNewCookies(cookies, response.cookies);
+
+ // Request redirected page
+ logMsg("Sending request \"" + request + "\"");
+ response = WebUtil.sendRequest("GET", InetAddress.getByName(hostname),
+ portnum, request, null, cookies);
+
+ // After a succesful http post request,
+ // Sun's Reference Implementation returns a redirected URL
+ // (Note: No cookies are sent back to the client at this point)
+ // Only when the client accesses the redirected URL,
+ // Sun RI sends a cookie (single sign on cookie) back to
+ // the client. So update cookies hashtable with new cookies
+ addNewCookies(cookies, response.cookies);
+
+ // Do not check for error code for testNum 7 and testNum 8
+ // those test access an unauthorized resource and expect
+ // error code.
+ if (testNum != 7 && testNum != 8) {
+ // Check that the page was found (no error).
+ if (response.isError()) {
+ logErr("Status Token " + response.statusToken);
+ logErr("Could not find " + request);
+ throw new Exception("test" + testNum + " failed.");
+ }
+ }
+ } else {
+ // After a successful post request, if a webserver
+ // returns the webresource without redirecting to new URL
+ // then update any new cookies received during this process.
+ addNewCookies(cookies, response.cookies);
+
+ }
+
+ return response;
+ }
+
+ /**
+ * Helper method that is used to update cookies
+ *
+ * This helper method retrieves cookies from "newCookies" hashtable and
+ * updates it to "oldCookies" hashtable
+ *
+ * @param oldCookies
+ * Hashtable containing original cookies
+ * @param newCookies
+ * Hashtable containing new cookies error messages.
+ */
+ public void addNewCookies(Hashtable oldCookies, Hashtable newCookies) {
+ // Add new cookie/cookies to the existing cookies Hashtable
+ for (Enumeration e = newCookies.keys(); e.hasMoreElements();) {
+ // get cookie name
+ String name = (String) e.nextElement();
+
+ // get value for this name
+ String value = (String) newCookies.get(name);
+
+ if (oldCookies == null) {
+ oldCookies = new Hashtable();
+ }
+
+ // Add this name value pair (cookie) to old cookies
+ oldCookies.put(name.trim(), value.trim());
+
+ }
+ }
+
+ /**
+ * Get the HttpResponse, and check the status code to see if matches one of
+ * the expected status codes.
+ *
+ * @param request-
+ * @String request URL
+ * @param expectedCodes
+ * - @List<@String> status codes we will test for
+ * @param testName
+ * - The name calling test
+ */
+ private void testStatusCodes(String request, List expectedCodes,
+ String testName) throws Exception {
+
+ try {
+ logMsg("Sending request \"" + request + "\"");
+ response = WebUtil.sendRequest("GET", InetAddress.getByName(hostname),
+ portnum, request, null, null);
+
+ // Call followRedirect() to make sure we receive the required page
+ response = followRedirect(response, 7);
+
+ // Check status code(s).
+ if (expectedCodes.contains(response.statusToken)) {
+ logMsg("Status Token " + response.statusToken);
+ logMsg("Received expected error code");
+
+ } else {
+ logErr("Did not receive expected error code" + request);
+ logMsg("Status Token " + response.statusToken);
+ logErr("Page content: ");
+ logErr(response.content);
+ throw new Exception(testName + " failed.");
+ }
+
+ } catch (Exception e) {
+ logErr("Caught exception: " + e.getMessage());
+ e.printStackTrace();
+ throw new Exception(testName + " failed: ", e);
+ }
+
+ }
+}
diff --git a/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/TestCase.java b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/TestCase.java
new file mode 100644
index 0000000000..2719db0acb
--- /dev/null
+++ b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/TestCase.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2007, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/*
+ * $Id$
+ */
+
+package com.sun.ts.tests.servlet.common.request;
+
+/**
+ * This interface defines a base set of methods required used by a TS test case.
+ */
+public interface TestCase {
+
+ /**
+ * Executes the test case.
+ *
+ * @throws Exception if the test fails for any reason.
+ */
+ public void execute() throws Exception;
+
+ /**
+ * Sets the name of the test case.
+ *
+ * @param name
+ * of the test case
+ */
+ public void setName(String name);
+
+ /**
+ * Returns the name of this test case.
+ *
+ * @return test case name
+ */
+ public String getName();
+
+ /**
+ * Sets the state for this test case. This state will differ from
+ * implementation to implementation.
+ *
+ * @param state
+ * test state
+ */
+ public void setState(Object state);
+
+ /**
+ * Returns the state of the test case. The state returned could possibly
+ * differ depending on when this method is called and when the test case has
+ * been executed.
+ */
+ public Object getState();
+
+}
diff --git a/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/ValidationFactory.java b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/ValidationFactory.java
new file mode 100644
index 0000000000..3caec6fd58
--- /dev/null
+++ b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/ValidationFactory.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2007, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/*
+ * $Id$
+ */
+
+package com.sun.ts.tests.servlet.common.request;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Returns a ValidationStrategy instance used to validate a response against a
+ * particular WebTestCase
+ *
+ * @author Ryan Lubke
+ * @version %I%
+ */
+public class ValidationFactory {
+
+ private static final Logger LOGGER = LoggerFactory.getLogger(ValidationFactory.class);
+
+ /**
+ * Private constructor as all interaction with the class is through the
+ * getInstance() method.
+ */
+ private ValidationFactory() {
+ }
+
+ /*
+ * public methods
+ * ========================================================================
+ */
+
+ /**
+ * Returns a ValidationStrategy instance based on the available factory types.
+ *
+ * @param validator
+ * Validator instance to obtain
+ * @return a ValidationStrategy instance or null if the instance could not be
+ * obtained.
+ */
+ public static ValidationStrategy getInstance(String validator) {
+ try {
+ Object o = Thread.currentThread().getContextClassLoader()
+ .loadClass(validator).getDeclaredConstructor().newInstance();
+ if (o instanceof ValidationStrategy) {
+ return (ValidationStrategy) o;
+ }
+ } catch (Throwable t) {
+ LOGGER.info("[ValidationFactory] Unable to obtain ValidationStrategy instance: {}", validator);
+ }
+ return null;
+ }
+}
diff --git a/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/ValidationStrategy.java b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/ValidationStrategy.java
new file mode 100644
index 0000000000..16e443f814
--- /dev/null
+++ b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/ValidationStrategy.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2007, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/*
+ * $Id$
+ */
+package com.sun.ts.tests.servlet.common.request;
+
+/**
+ * A ValidationStrategy is used to compare a server response with a configured
+ * test case. How this validation is performed is up to the concrete
+ * implementation.
+ */
+public interface ValidationStrategy {
+ boolean validate(WebTestCase testCase) throws Exception;
+}
diff --git a/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/WebTestCase.java b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/WebTestCase.java
new file mode 100644
index 0000000000..c4e6f4dc2c
--- /dev/null
+++ b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/WebTestCase.java
@@ -0,0 +1,553 @@
+/*
+ * Copyright (c) 2007, 2020 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/*
+ * $Id$
+ */
+
+package com.sun.ts.tests.servlet.common.request;
+
+import com.sun.ts.tests.servlet.common.response.validation.WebValidatorBase;
+import org.apache.commons.httpclient.Header;
+import org.apache.commons.httpclient.HttpState;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.StringTokenizer;
+
+/**
+ * A TestCase implementation for HTTP-based testing. This allows the user to set
+ * criteria for test success which will be compared against the response from
+ * the server.
+ */
+public class WebTestCase implements TestCase {
+
+ private static final Logger LOGGER = LoggerFactory.getLogger(WebTestCase.class.getName());
+
+ public static final String BASED_STRATEGY = WebValidatorBase.class.getName();
+
+
+
+ /**
+ * The request for this case.
+ */
+ private HttpRequest _request = null;
+
+ /**
+ * The server's response.
+ */
+ private HttpResponse _response = null;
+
+ // use HttpMethod instances to store test
+ // case headers that are expected or not
+ // expected.
+
+ /**
+ * Storage for headers that are expected in the response
+ */
+ private Map _expected = null;
+
+ /**
+ * Storage for headers that are not expected in the response
+ */
+ private Map _unexpected = null;
+
+ /**
+ * Expected response status code.
+ */
+ private String _statusCode = null;
+
+ /**
+ * Expected response reason phrase.
+ */
+ private String _reasonPhrase = null;
+
+ /**
+ * A List of strings that will be searched for in the response in the order
+ * they appear in the list.
+ */
+ private List _searchStrings = null;
+
+ /**
+ * A List of case insensitive strings that will be searched for in the
+ * response in the order they appear in the list.
+ */
+ private List _searchStringsNoCase = null;
+
+ /**
+ * A List of strings that will be search for in the response with no attention
+ * paid to the order they appear.
+ */
+ private List _unorderedSearchStrings = null;
+
+ /**
+ * A List of strings that should not be in the server's response.
+ */
+ private List _uSearchStrings = null;
+
+ /**
+ * Indicates whether a response body should be expected or not.
+ */
+ private boolean _expectResponseBody = true;
+
+ /**
+ * Strategy to use when validating the test case against the server's
+ * response.
+ */
+ private ValidationStrategy _strategy = null;
+
+ /**
+ * Logical name for test case.
+ */
+ private String _name = "Test Case";
+
+ /**
+ * Creates a new instance of WebTestCase By default, a new WebTestCase
+ * instance will use the TokenizedValidator to verify the response with the
+ * configured properties of the test case.
+ */
+ public WebTestCase() {
+ _strategy = ValidationFactory.getInstance(BASED_STRATEGY);
+ }
+
+ /*
+ * public methods
+ * ========================================================================
+ */
+ /**
+ * Executes the test case.
+ *
+ * @throws Exception
+ * if the test fails for any reason.
+ * @throws IllegalStateException
+ * if no request was configured or if no Validator is available at
+ * runtime.
+ */
+ public void execute() throws Exception {
+
+ // If no request was created, we can't run.
+ if (_request == null) {
+ throw new IllegalStateException("[FATAL] HttpRequest is null.");
+ }
+
+ // If no stragey instance is available (strange, but has happened),
+ // fail.
+ if (_strategy == null) {
+ throw new IllegalStateException("[FATAL] No Validator available.");
+ }
+
+ try {
+ _response = _request.execute();
+ } catch (Throwable t) {
+ String message = t.getMessage();
+ throw new Exception("[FATAL] Unexpected failure during test execution." + (message == null ? t.toString() : message), t);
+ }
+
+ // Validate this test case instance
+ if (!_strategy.validate(this)) {
+ throw new Exception("Test FAILED!");
+ }
+
+ }
+
+ /**
+ * Sets the status code to be expected in the response from the server, i.e.
+ * 500 or 404, etc.
+ *
+ * @param statusCode
+ * the expected status code
+ */
+ public void setExpectedStatusCode(String statusCode) {
+ _statusCode = statusCode;
+ }
+
+ /**
+ * Sets the reason phrase to be expected in the response from the server.
+ *
+ * @param reasonPhrase
+ * the expected reason-phrase
+ */
+ public void setExpectedReasonPhrase(String reasonPhrase) {
+ _reasonPhrase = reasonPhrase;
+ }
+
+ /**
+ * Adds a header that is to be expected in the response from the server.
+ *
+ * @param header
+ * in the format of : (test:foo)
+ */
+ public void addExpectedHeader(String header) {
+ if (_expected == null) {
+ _expected = new HashMap<>();
+ }
+ addHeader(_expected, header);
+ }
+
+ /**
+ * Sets the request that should be dispatched by this test case.
+ *
+ * @param request
+ * the HTTP request used for this test case
+ */
+ public void setRequest(HttpRequest request) {
+ _request = request;
+ }
+
+ /**
+ * Adds a header that is should not be in the server's response.
+ *
+ * @param header
+ * in the format of : (test:foo)
+ */
+ public void addUnexpectedHeader(String header) {
+ if (_unexpected == null) {
+ _unexpected = new HashMap<>();
+ }
+ addHeader(_unexpected, header);
+ }
+
+ /**
+ * Enables/Disables an assertion that a response body is present.
+ *
+ * @param value
+ * a value of true will enable the assertion.
+ */
+ public void setAssertNoResponseBody(boolean value) {
+ }
+
+ /**
+ * Sets a string that will be scanned for and expected in the response body
+ * from the server.
+ *
+ * If multiple search strings are required, one can either call this method
+ * for each string, or pass in one string with pipe | delimiting
+ * the individual search strings within the large string.
+ *
+ * @param searchString
+ * a string expected in the server's response body
+ */
+ public void setResponseSearchString(String searchString) {
+ if (_searchStrings == null) {
+ _searchStrings = new ArrayList<>();
+ }
+ addSearchStrings(_searchStrings, searchString);
+ }
+
+ /**
+ * Sets a string that will be scanned for and expected in the response body
+ * from the server.
+ *
+ * If multiple search strings are required, one can either call this method
+ * for each string, or pass in one string with pipe | delimiting
+ * the individual search strings within the large string.
+ *
+ * @param searchString
+ * a case insensitive string expected in the server's response body
+ */
+ public void setResponseSearchStringIgnoreCase(String searchString) {
+ if (_searchStringsNoCase == null) {
+ _searchStringsNoCase = new ArrayList<>();
+ }
+ addSearchStrings(_searchStringsNoCase, searchString);
+ }
+
+ /**
+ * Sets a string that will be scanned for and should not be present in the
+ * response body from the server.
+ *
+ * If multiple search strings are required, one can either call this method
+ * for each string, or pass in one string with pipe | delimiting
+ * the individual search strings within the large string.
+ *
+ * @param searchString
+ * a string that is not expected in the server's response body
+ */
+ public void setUnexpectedResponseSearchString(String searchString) {
+ if (_uSearchStrings == null) {
+ _uSearchStrings = new ArrayList<>();
+ }
+ addSearchStrings(_uSearchStrings, searchString);
+ }
+
+ /**
+ * Sets a string or series of strings that will be searched for in the
+ * response. If multiple search strings are required, one can either call this
+ * method for each string, or pass in one string with pipe |
+ * delimiting the individual search strings within the large string.
+ *
+ * @param searchString
+ * a string that is not expected in the server's response body
+ */
+ public void setUnorderedSearchString(String searchString) {
+ if (_unorderedSearchStrings == null) {
+ _unorderedSearchStrings = new ArrayList<>();
+ }
+ addSearchStrings(_unorderedSearchStrings, searchString);
+ }
+
+ /**
+ * Returns the list of search strings.
+ *
+ * @return the list of search strings.
+ */
+ public List getUnorderedSearchStrings() {
+ return _unorderedSearchStrings;
+ }
+
+ /**
+ * Returns the response for this particular test case.
+ *
+ * @return an HttpResponse object
+ */
+ public HttpResponse getResponse() {
+ return _response;
+ }
+
+ /**
+ * Returns an array of Header objects that are expected to be found in the
+ * responst.
+ *
+ * @return an array of headers
+ */
+ public Header[] getExpectedHeaders() {
+ if (_expected == null) {
+ return null;
+ }
+ return _expected.values().toArray(new Header[0]);
+ }
+
+ /**
+ * Returns an array of Header objects that are not expected to be found in the
+ * responst.
+ *
+ * @return an array of headers
+ */
+ public Header[] getUnexpectedHeaders() {
+ if (_unexpected == null) {
+ return null;
+ }
+ return _unexpected.values().toArray(new Header[0]);
+ }
+
+ /**
+ * Returns the status code expected to be found in the server's response
+ *
+ * @return status code
+ */
+ public String getStatusCode() {
+ return _statusCode;
+ }
+
+ /**
+ * Returns the reason phrase that is expected to be found in the server's
+ * response.
+ *
+ * @return reason phrase
+ */
+ public String getReasonPhrase() {
+ return _reasonPhrase;
+ }
+
+ /**
+ * Returns the configured list of strings that will be used when scanning the
+ * server's response.
+ *
+ * @return list of Strings
+ */
+ public List getSearchStrings() {
+ if (_searchStrings == null) {
+ return null;
+ }
+ return _searchStrings;
+ }
+
+ /**
+ * Returns the configured list of strings that will be used when scanning the
+ * server's response.
+ *
+ * @return list of case insensitive Strings
+ */
+ public List getSearchStringsNoCase() {
+ if (_searchStringsNoCase == null) {
+ return null;
+ }
+ return _searchStringsNoCase;
+ }
+
+ /**
+ * Returns the configured list of strings that will be used when scanning the
+ * server's response (these strings are not expected in the response).
+ *
+ * @return list of Strings
+ */
+ public List getUnexpectedSearchStrings() {
+ if (_uSearchStrings == null) {
+ return null;
+ }
+ return _uSearchStrings;
+ }
+
+ /**
+ * Returns an indicator on whether a response body is expected or not.
+ *
+ * @return boolean value
+ */
+ public boolean getExpectResponseBody() {
+ return _expectResponseBody;
+ }
+
+ /**
+ * Returns the HttpRequest for this particular test case.
+ *
+ * @return HttpRequest of this test case
+ */
+ public HttpRequest getRequest() {
+ return _request;
+ }
+
+ /**
+ * Returns the state for this particular test case.
+ *
+ * @return test state
+ */
+ public Object getState() {
+ if (_response != null) {
+ return _response.getState();
+ } else {
+ // an initial request for state
+ return _request.getState();
+ }
+ }
+
+ /**
+ * Sets the state for this test case.
+ *
+ * @param state
+ * test state
+ */
+ public void setState(Object state) {
+ _request.setState((HttpState) state);
+ }
+
+ /**
+ * Sets a logical name for this test case.
+ *
+ * @param name
+ * the logical name for this test
+ */
+ public void setName(String name) {
+ _name = name;
+ }
+
+ /**
+ * Returns the logical name for this test case.
+ *
+ * @return test name
+ */
+ public String getName() {
+ return _name;
+ }
+
+ /**
+ * Sets the validation strategy for this test case instance.
+ *
+ * @param validator
+ * - the fully qualified class name of the response validator to use.
+ */
+ public void setStrategy(String validator) {
+ ValidationStrategy strat = ValidationFactory.getInstance(validator);
+ if (strat != null) {
+ _strategy = strat;
+ } else {
+ LOGGER.info("[WebTestCase][WARNING] An attempt was made to use a non-existing validator ({}) . Falling back to the TokenizedValidator", validator);
+ }
+ }
+
+ /**
+ * Returns the class name of the response validator used.
+ *
+ * @return the fully qualified class of the validator used
+ */
+ public String getStrategy() {
+ return _strategy.getClass().getName();
+ }
+
+ /*
+ * Private Methods
+ * ===========================================================================
+ */
+
+ /**
+ * Utility method to add headers to test case holder objects.
+ *
+ * @param map
+ * the object in which to add header to
+ * @param headerString
+ * String representation of a header in the form of
+ * :
+ */
+ private void addHeader(Map map, String headerString) {
+ LOGGER.debug("[WebTestCase] addHeader utility method called: {}", headerString);
+ StringTokenizer st = new StringTokenizer(headerString, "|");
+ while (st.hasMoreTokens()) {
+ String head = st.nextToken();
+ int colIdx = head.indexOf(':');
+ String name = head.substring(0, colIdx).trim();
+ String value = head.substring(colIdx + 1).trim();
+ LOGGER.debug("[WebTestCase] Adding test header: {}, {}", name, value);
+ Header header = map.get(name);
+ if (header != null) {
+ map.put(name, createNewHeader(value, header));
+ } else {
+ map.put(name, new Header(name, value));
+ }
+ }
+ }
+
+ /**
+ * Creates a new header based of the provided header and value.
+ *
+ * @param newValue
+ * - the new value to add to an existing header
+ * @param header
+ * - the original header
+ * @return new Header
+ */
+ private Header createNewHeader(String newValue, Header header) {
+ String oldValue = header.getValue();
+ return new Header(header.getName(), oldValue + ", " + newValue);
+ }
+
+ /**
+ * Adds a search string to the provided list
+ *
+ * @param stringList
+ * - list to add the string to
+ * @param s
+ * - the search string
+ */
+ private void addSearchStrings(List stringList, String s) {
+ StringTokenizer st = new StringTokenizer(s, "|");
+ while (st.hasMoreTokens()) {
+ stringList.add(st.nextToken());
+ }
+ }
+}
diff --git a/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/build.xml b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/build.xml
new file mode 100644
index 0000000000..d02bb0dd62
--- /dev/null
+++ b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/request/build.xml
@@ -0,0 +1,22 @@
+
+
+
+
+
diff --git a/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/response/HttpResponseClient.java b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/response/HttpResponseClient.java
new file mode 100644
index 0000000000..095a438612
--- /dev/null
+++ b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/response/HttpResponseClient.java
@@ -0,0 +1,278 @@
+/*
+ * Copyright (c) 2007, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/*
+ * $Id$
+ */
+
+package com.sun.ts.tests.servlet.common.response;
+
+import com.sun.ts.tests.servlet.common.util.Data;
+
+public class HttpResponseClient extends ResponseClient {
+
+
+ public void addCookieTest() throws Exception {
+ String testName = "addCookieTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST, "GET " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(EXPECTED_HEADERS,
+ "set-Cookie:cookie1=value1|set-Cookie:cookie2=value2");
+ invoke();
+ }
+
+
+ public void addDateHeaderTest() throws Exception {
+ String testName = "addDateHeaderTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST, "GET " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(EXPECTED_HEADERS,
+ "DateInfo:Sat, 25 Apr 1970 07:29:03 GMT");
+ invoke();
+ }
+
+
+ public void addHeaderTest() throws Exception {
+ String testName = "addHeaderTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST, "GET " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(EXPECTED_HEADERS,
+ "header1:value1|header1:value11|header2:value2");
+ invoke();
+ }
+
+
+ public void addIntHeaderTest() throws Exception {
+ String testName = "addIntHeaderTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST, "GET " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(EXPECTED_HEADERS,
+ "intHeader1:1|intHeader1:11|intHeader2:2");
+ invoke();
+ }
+
+
+ public void containsHeaderTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "containsHeaderTest");
+ invoke();
+ }
+
+
+ public void sendErrorClearBufferTest() throws Exception {
+ String testName = "sendErrorClearBufferTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST, "GET " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(STATUS_CODE, GONE);
+ TEST_PROPS.setProperty(UNEXPECTED_RESPONSE_MATCH,
+ "THIS TEXT SHOULD NOT APPEAR");
+ invoke();
+ }
+
+
+ public void sendErrorIllegalStateExceptionTest() throws Exception {
+ String testName = "sendErrorIllegalStateExceptionTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST, "GET " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(SEARCH_STRING,
+ "THIS TEXT SHOULD APPEAR|" + Data.PASSED);
+ invoke();
+ }
+
+
+ public void sendError_StringTest() throws Exception {
+ String testName = "sendError_StringTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST, "GET " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(STATUS_CODE, GONE);
+ TEST_PROPS.setProperty(SEARCH_STRING, "in sendError_StringTest servlet");
+ TEST_PROPS.setProperty(EXPECTED_HEADERS,
+ "Content-Type:text/html|header:sendError_StringTest|set-Cookie:cookie1=value1");
+ TEST_PROPS.setProperty(UNEXPECTED_RESPONSE_MATCH,
+ "THIS TEXT SHOULD NOT APPEAR");
+ invoke();
+ }
+
+
+ public void sendError_StringIllegalStateExceptionTest() throws Exception {
+ String testName = "sendError_StringIllegalStateExceptionTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST, "GET " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(SEARCH_STRING,
+ "THIS TEXT SHOULD APPEAR|" + Data.PASSED);
+ invoke();
+ }
+
+
+ public void sendError_StringErrorPageTest() throws Exception {
+ String testName = "sendError_StringErrorPageTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(STATUS_CODE, "411");
+ TEST_PROPS.setProperty(REQUEST, "GET " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(SEARCH_STRING, "Status Code: 411");
+ TEST_PROPS.setProperty(UNEXPECTED_RESPONSE_MATCH,
+ "THIS TEXT SHOULD NOT APPEAR");
+ invoke();
+ }
+
+
+ public void sendRedirectWithLeadingSlashTest() throws Exception {
+ String testName = "sendRedirectWithLeadingSlashTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST, "GET " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(EXPECTED_HEADERS,
+ "Location: http://" + _hostname + ":" + _port + "/RedirectedTest");
+ TEST_PROPS.setProperty(STATUS_CODE, MOVED_TEMPORARY);
+ invoke();
+ }
+
+
+ public void sendRedirectWithoutLeadingSlashTest() throws Exception {
+ String testName = "sendRedirectWithoutLeadingSlashTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST, "GET " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(EXPECTED_HEADERS, "Location: http://" + _hostname
+ + ":" + _port + "" + getContextRoot() + "/RedirectedTest");
+ TEST_PROPS.setProperty(STATUS_CODE, MOVED_TEMPORARY);
+ invoke();
+ }
+
+
+ public void sendRedirectIllegalStateExceptionTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "sendRedirectIllegalStateExceptionTest");
+ invoke();
+ }
+
+
+ public void setDateHeaderTest() throws Exception {
+ String testName = "setDateHeaderTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST, "GET " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(EXPECTED_HEADERS,
+ "DateInfo:Sat, 25 Apr 1970 07:29:03 GMT");
+ invoke();
+ }
+
+
+ public void setDateHeaderOverrideTest() throws Exception {
+ String testName = "setDateHeaderOverrideTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST, "GET " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(EXPECTED_HEADERS,
+ "DateInfo:Sat, 25 Apr 1970 07:29:04 GMT");
+ invoke();
+ }
+
+
+ public void setHeaderTest() throws Exception {
+ String testName = "setHeaderTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST, "GET " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(EXPECTED_HEADERS, "header:value1");
+ invoke();
+ }
+
+
+ public void setHeaderOverrideTest() throws Exception {
+ String testName = "setHeaderOverrideTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST, "GET " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(EXPECTED_HEADERS, "header:value2");
+ invoke();
+ }
+
+
+ public void setMultiHeaderTest() throws Exception {
+ String testName = "setMultiHeaderTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST, "GET " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(EXPECTED_HEADERS, "header:value3");
+ invoke();
+ }
+
+
+ public void setIntHeaderTest() throws Exception {
+ String testName = "setIntHeaderTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST, "GET " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(EXPECTED_HEADERS, "intHeader:2");
+ invoke();
+ }
+
+
+ public void setStatusTest() throws Exception {
+ String testName = "setStatusTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST, "GET " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(STATUS_CODE, OK);
+ invoke();
+ }
+
+
+ public void setStatusTest1() throws Exception {
+ String testName = "setStatusTest1";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST, "GET " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(STATUS_CODE, NOT_FOUND);
+ invoke();
+ }
+
+ /*
+ * Servlet 3.0 tests
+ */
+
+ public void getHeadersTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getHeadersTest");
+ invoke();
+ }
+
+
+ public void getHeaderTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getHeaderTest");
+ invoke();
+ }
+
+
+ public void getHeaderNamesTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getHeaderNamesTest");
+ invoke();
+ }
+
+
+ public void getStatusTest() throws Exception {
+ String testName = "getStatusTest";
+ TEST_PROPS.setProperty(APITEST, testName);
+ invoke();
+ }
+}
diff --git a/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/response/HttpResponseTestServlet.java b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/response/HttpResponseTestServlet.java
new file mode 100644
index 0000000000..e74049ece3
--- /dev/null
+++ b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/response/HttpResponseTestServlet.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2007, 2020 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/*
+ * $Id$
+ */
+
+/*
+ * $URL$ $LastChangedDate$
+ */
+
+package com.sun.ts.tests.servlet.common.response;
+
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+import jakarta.servlet.ServletConfig;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.ServletRequest;
+import jakarta.servlet.ServletResponse;
+import jakarta.servlet.http.HttpServlet;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+
+public class HttpResponseTestServlet extends HttpServlet {
+
+ private static final String TEST_HEADER = "testname";
+
+ private static final Class[] HTTP_TEST_ARGS = { HttpServletRequest.class,
+ HttpServletResponse.class };
+
+ private static final Class[] TEST_ARGS = { ServletRequest.class,
+ ServletResponse.class, };
+
+ private static final Class[][] ALL_TYPES = { TEST_ARGS, HTTP_TEST_ARGS };
+
+ public void init(ServletConfig servletConfig) throws ServletException {
+ super.init(servletConfig);
+ }
+
+ public void service(HttpServletRequest servletRequest,
+ HttpServletResponse servletResponse)
+ throws ServletException, IOException {
+ String test = servletRequest.getParameter(TEST_HEADER).trim();
+ Method method = null;
+ for (int i = 0; i < ALL_TYPES.length; i++) {
+ try {
+ method = ResponseTests.class.getDeclaredMethod(test, ALL_TYPES[i]);
+ break;
+ } catch (NoSuchMethodException nsme) {
+ ; // do nothing
+ }
+ }
+
+ if (method != null) {
+ invokeTest(method, new Object[] { servletRequest, servletResponse });
+ } else {
+ throw new ServletException("No such test: " + test);
+ }
+
+ }
+
+ private void invokeTest(Method toBeInvoked, Object[] paramValues)
+ throws ServletException {
+ try {
+ toBeInvoked.invoke(null, paramValues);
+ } catch (InvocationTargetException ite) {
+ throw new ServletException(ite.getTargetException());
+ } catch (Throwable t) {
+ throw new ServletException(
+ "Error executing test: " + toBeInvoked.getName(), t);
+ }
+ }
+}
diff --git a/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/response/ResponseClient.java b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/response/ResponseClient.java
new file mode 100644
index 0000000000..04abbeb745
--- /dev/null
+++ b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/response/ResponseClient.java
@@ -0,0 +1,291 @@
+/*
+ * Copyright (c) 2007, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/*
+ * $Id$
+ */
+
+package com.sun.ts.tests.servlet.common.response;
+
+import com.sun.ts.tests.servlet.common.client.AbstractUrlClient;
+import com.sun.ts.tests.servlet.common.util.Data;
+
+public class ResponseClient extends AbstractUrlClient {
+
+
+ public void flushBufferTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "flushBufferTest");
+ invoke();
+ }
+
+
+ public void getBufferSizeTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getBufferSizeTest");
+ invoke();
+ }
+
+
+ public void getLocaleDefaultTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getLocaleDefaultTest");
+ invoke();
+ }
+
+
+ public void getLocaleTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getLocaleTest");
+ invoke();
+ }
+
+
+ public void getOutputStreamTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getOutputStreamTest");
+ invoke();
+ }
+
+
+ public void getOutputStreamFlushTest() throws Exception {
+ String testName = "getOutputStreamFlushTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST, "GET " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(SEARCH_STRING,
+ "in getOutputStreamFlushTest|" + Data.PASSED);
+ invoke();
+ }
+
+
+ public void getOutputStreamIllegalStateExceptionTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getOutputStreamIllegalStateExceptionTest");
+ invoke();
+ }
+
+
+ public void getWriterTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getWriterTest");
+ TEST_PROPS.setProperty(REQUEST_HEADERS,
+ "Content-Type: text/html;charset=ISO-8859-1");
+ TEST_PROPS.setProperty(EXPECTED_HEADERS, "Content-Type: text/html");
+ TEST_PROPS.setProperty(SEARCH_STRING, Data.PASSED);
+ invoke();
+ }
+
+
+ public void getWriterFlushTest() throws Exception {
+ String testName = "getWriterFlushTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST, "GET " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(SEARCH_STRING, "in test|" + Data.PASSED);
+ invoke();
+ }
+
+
+ public void getWriterAfterTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getWriterAfterTest");
+ TEST_PROPS.setProperty(REQUEST_HEADERS,
+ "Content-Type: text/html;charset=ISO-8859-1");
+ TEST_PROPS.setProperty(EXPECTED_HEADERS,
+ "Content-Type: text/html;charset=ISO-8859-7");
+ invoke();
+ }
+
+
+ public void getWriterIllegalStateExceptionTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getWriterIllegalStateExceptionTest");
+ invoke();
+ }
+
+
+ public void getWriterUnsupportedEncodingExceptionTest() throws Exception {
+ String testName = "getWriterUnsupportedEncodingExceptionTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST,
+ "GET " + getContextRoot() + "/" + testName + " HTTP/1.1");
+ invoke();
+ testName = "checkTestResult";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST,
+ "GET " + getContextRoot() + "/" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(SEARCH_STRING, Data.PASSED);
+ invoke();
+ }
+
+
+ public void isCommittedTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "isCommittedTest");
+ invoke();
+ }
+
+
+ public void resetBufferTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "resetBufferTest");
+ invoke();
+ }
+
+
+ public void resetTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "resetTest");
+ invoke();
+ }
+
+
+ public void resetTest1() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "resetTest1");
+ TEST_PROPS.setProperty(UNEXPECTED_HEADERS,
+ "Content-Type: application/java-archive; charset=Shift_Jis");
+ TEST_PROPS.setProperty(UNEXPECTED_RESPONSE_MATCH, "BigNoNo");
+ TEST_PROPS.setProperty(SEARCH_STRING, "YesPlease");
+ invoke();
+ }
+
+
+ public void resetIllegalStateExceptionTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "resetIllegalStateExceptionTest");
+ invoke();
+ }
+
+
+ public void getCharacterEncodingTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getCharacterEncodingTest");
+ invoke();
+ }
+
+
+ public void getCharacterEncodingDefaultTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getCharacterEncodingDefaultTest");
+ invoke();
+ }
+
+
+ public void setCharacterEncodingTest() throws Exception {
+ String testName = "setCharacterEncodingTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST_HEADERS,
+ "Content-Type: text/html;charset=ISO-8859-1");
+ TEST_PROPS.setProperty(REQUEST,
+ "GET " + getContextRoot() + "/" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(EXPECTED_HEADERS,
+ "Content-Type: text/html;charset=ISO-8859-7");
+ TEST_PROPS.setProperty(SEARCH_STRING, Data.PASSED);
+ invoke();
+ }
+
+
+ public void setBufferSizeTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "setBufferSizeTest");
+ invoke();
+ }
+
+
+ public void setBufferSizeIllegalStateExceptionTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "setBufferSizeIllegalStateExceptionTest");
+ invoke();
+ }
+
+
+ public void setContentLengthTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "setContentLengthTest");
+ int lenn = Data.PASSED.length();
+ TEST_PROPS.setProperty(EXPECTED_HEADERS, "Content-Length:" + lenn);
+ invoke();
+ }
+
+
+ public void getContentTypeTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getContentTypeTest");
+ TEST_PROPS.setProperty(REQUEST_HEADERS, "Content-Type:text/html");
+ TEST_PROPS.setProperty(EXPECTED_HEADERS,
+ "Content-Type:text/html;charset=ISO-8859-1");
+ invoke();
+ }
+
+
+ public void getContentType1Test() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getContentType1Test");
+ TEST_PROPS.setProperty(EXPECTED_HEADERS, "Content-Type:text/html");
+ invoke();
+ }
+
+
+ public void getContentTypeNullTest() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getContentTypeNullTest");
+ invoke();
+ }
+
+
+ public void getContentTypeNull1Test() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getContentTypeNull1Test");
+ invoke();
+ }
+
+
+ public void getContentTypeNull2Test() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "getContentTypeNull2Test");
+ invoke();
+ }
+
+
+ public void setContentTypeTest() throws Exception {
+ String testName = "setContentTypeTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST, "GET " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(EXPECTED_HEADERS, "Content-Type:text/html");
+ TEST_PROPS.setProperty(IGNORE_BODY, "true");
+ invoke();
+ }
+
+
+ public void setContentType1Test() throws Exception {
+ TEST_PROPS.setProperty(APITEST, "setContentType1Test");
+ invoke();
+ }
+
+
+ public void setContentType2Test() throws Exception {
+ String testName = "setContentType2Test";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST, "GET " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(EXPECTED_HEADERS, "Content-Type:text/html");
+ TEST_PROPS.setProperty(UNEXPECTED_HEADERS, "Content-Type:text/plain");
+ TEST_PROPS.setProperty(IGNORE_BODY, "true");
+ invoke();
+ }
+
+
+ public void setLocaleTest() throws Exception {
+ String testName = "setLocaleTest";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST, "GET " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(EXPECTED_HEADERS, "Content-Language:en-US");
+ TEST_PROPS.setProperty(IGNORE_BODY, "true");
+ invoke();
+ }
+
+
+ public void setLocale1Test() throws Exception {
+ String testName = "setLocale1Test";
+ TEST_PROPS.setProperty(TEST_NAME, testName);
+ TEST_PROPS.setProperty(REQUEST, "GET " + getContextRoot() + "/"
+ + getServletName() + "?testname=" + testName + " HTTP/1.1");
+ TEST_PROPS.setProperty(EXPECTED_HEADERS,
+ "Content-Type:text/html;charset=Shift_Jis");
+ TEST_PROPS.setProperty(IGNORE_BODY, "true");
+ invoke();
+ }
+}
diff --git a/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/response/ResponseTestServlet.java b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/response/ResponseTestServlet.java
new file mode 100644
index 0000000000..72b355b2db
--- /dev/null
+++ b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/response/ResponseTestServlet.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2007, 2020 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/*
+ * $Id$
+ */
+
+/*
+ * $URL$ $LastChangedDate$
+ */
+
+package com.sun.ts.tests.servlet.common.response;
+
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+import jakarta.servlet.GenericServlet;
+import jakarta.servlet.ServletConfig;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.ServletRequest;
+import jakarta.servlet.ServletResponse;
+
+public class ResponseTestServlet extends GenericServlet {
+
+ private static final String TEST_HEADER = "testname";
+
+ private static final Class[] TEST_ARGS = { ServletRequest.class,
+ ServletResponse.class };
+
+ public void init(ServletConfig servletConfig) throws ServletException {
+ super.init(servletConfig);
+ }
+
+ public void service(ServletRequest servletRequest,
+ ServletResponse servletResponse) throws ServletException, IOException {
+ String test = servletRequest.getParameter(TEST_HEADER).trim();
+ try {
+ Method method = ResponseTests.class.getMethod(test, TEST_ARGS);
+ method.invoke(null, new Object[] { servletRequest, servletResponse });
+ } catch (InvocationTargetException ite) {
+ throw new ServletException(ite.getTargetException());
+ } catch (NoSuchMethodException nsme) {
+ throw new ServletException("Test: " + test + " does not exist");
+ } catch (Throwable t) {
+ throw new ServletException("Error executing test: " + test, t);
+ }
+
+ }
+}
diff --git a/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/response/ResponseTests.java b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/response/ResponseTests.java
new file mode 100644
index 0000000000..51933080fb
--- /dev/null
+++ b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/response/ResponseTests.java
@@ -0,0 +1,1369 @@
+/*
+ * Copyright (c) 2007, 2022 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/*
+ * $URL$ $LastChangedDate$
+ */
+
+package com.sun.ts.tests.servlet.common.response;
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.UnsupportedEncodingException;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Locale;
+
+import com.sun.ts.tests.servlet.common.util.Data;
+import com.sun.ts.tests.servlet.common.util.ServletTestUtil;
+
+import jakarta.servlet.ServletException;
+import jakarta.servlet.ServletOutputStream;
+import jakarta.servlet.ServletRequest;
+import jakarta.servlet.ServletResponse;
+import jakarta.servlet.ServletResponseWrapper;
+import jakarta.servlet.http.Cookie;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import jakarta.servlet.http.HttpServletResponseWrapper;
+
+public class ResponseTests {
+
+ // --------------------------- ServletResponse
+ // ---------------------------------
+
+ public static void responseWrapperConstructorTest(ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+
+ PrintWriter pw = response.getWriter();
+ ServletResponseWrapper srw = new ServletResponseWrapper(response);
+ if (srw != null) {
+ ServletTestUtil.printResult(pw, true);
+ } else {
+ ServletTestUtil.printResult(pw, false);
+ }
+ }
+
+ public static void responseWrapperGetResponseTest(ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+
+ PrintWriter pw = response.getWriter();
+ boolean passed = false;
+ ServletResponseWrapper srw = new ServletResponseWrapper(response);
+ if (srw != null) {
+ ServletResponse sr = srw.getResponse();
+ if (!response.equals(sr)) {
+ passed = false;
+ pw.println("getResponse failed to return the same response object");
+ } else {
+ passed = true;
+ }
+ } else {
+ passed = false;
+ pw.println("constructor failed");
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void responseWrapperSetResponseTest(ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+
+ PrintWriter pw = response.getWriter();
+ boolean passed = true;
+ ServletResponseWrapper srw = new ServletResponseWrapper(response);
+ if (srw != null) {
+ try {
+ srw.setResponse(response);
+ } catch (Throwable t) {
+ passed = false;
+ pw.println("Error: setResponse generated a Throwable");
+ t.printStackTrace(pw);
+ }
+ if (passed) {
+ ServletResponse sr = srw.getResponse();
+ if (!response.equals(sr)) {
+ passed = false;
+ pw.println("getResponse failed to return the same response object");
+ }
+ }
+ } else {
+ passed = false;
+ pw.println("constructor failed");
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void responseWrapperSetResponseIllegalArgumentExceptionTest(
+ ServletRequest request, ServletResponse response)
+ throws ServletException, IOException {
+
+ PrintWriter pw = response.getWriter();
+ boolean passed = false;
+ ServletResponseWrapper srw = new ServletResponseWrapper(response);
+ if (srw != null) {
+ try {
+ srw.setResponse(null);
+ passed = false;
+ pw.println(
+ "Error: an IllegalArgumentException should have been generated");
+ } catch (Throwable t) {
+ if (t instanceof IllegalArgumentException) {
+ passed = true;
+ } else {
+ passed = false;
+ pw.println(
+ "Exception thrown, but was not an instance of IllegalArgumentException .");
+ pw.println("instead received: " + t.getClass().getName());
+ }
+ }
+ } else {
+ passed = false;
+ pw.println("constructor failed");
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void flushBufferTest(ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+
+ ServletOutputStream sos = null;
+
+ try {
+ sos = response.getOutputStream();
+ response.setBufferSize(13);
+ response.setContentType("text/html");
+ ServletTestUtil.printResult(sos, true);
+
+ // after flushing the client should get this
+ response.flushBuffer();
+
+ sos.close();
+ } catch (Throwable t) {
+ throw new ServletException(t);
+ }
+ }
+
+ public static void getBufferSizeTest(ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+
+ final String IN_TEST = "in test";
+ int bSize = IN_TEST.length() * 2;
+ boolean passed = false;
+ PrintWriter pw = response.getWriter();
+
+ response.setBufferSize(bSize);
+ pw.println(IN_TEST);
+ response.flushBuffer();
+ int result = response.getBufferSize();
+ // needs to be greater than or equal to SetBufferSize value or zero .
+ if ((result >= bSize) || (result == 0)) {
+ passed = true;
+ } else {
+ passed = false;
+ pw.println("ServletRequest.getBufferSize() returned incorrect result");
+ pw.println("Expected result -> >= " + bSize + " or 0");
+ pw.println("Actual result -> " + result);
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getOutputStreamFlushTest(ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+
+ boolean passed = false;
+ ServletOutputStream sos = response.getOutputStream();
+ sos.println("in getOutputStreamFlushTest");
+ sos.flush();
+ if (response.isCommitted()) {
+ passed = true;
+ } else {
+ passed = false;
+ }
+ ServletTestUtil.printResult(sos, passed);
+ }
+
+ public static void getOutputStreamTest(ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+
+ ServletOutputStream sos = response.getOutputStream();
+ ServletTestUtil.printResult(sos, true);
+ }
+
+ public static void getOutputStreamIllegalStateExceptionTest(
+ ServletRequest request, ServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+ PrintWriter pw = response.getWriter();
+ try {
+ response.getOutputStream();
+ passed = false;
+ pw.println("getOutputStream() did not throw IllegalStateException ");
+ } catch (Throwable t) {
+ if (t instanceof IllegalStateException) {
+ passed = true;
+ } else {
+ passed = false;
+ pw.println(
+ "Exception thrown, but was not an instance of IllegalStateException.");
+ pw.println("instead received: " + t.getClass().getName());
+ }
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void setCharacterEncodingTest(ServletRequest request,
+ ServletResponse response) throws IOException {
+ boolean pass = true;
+ StringBuilder report = new StringBuilder();
+
+ // First need to know the default
+ String defaultEncoding = response.getCharacterEncoding();
+
+ report.append("Test 1: Direct UTF-8 then null:\n");
+ response.setCharacterEncoding("UTF-8");
+ if ("UTF-8".equalsIgnoreCase(response.getCharacterEncoding())) {
+ report.append(" Set with UTF-8 Pass\n");
+ } else {
+ pass = false;
+ report.append(" Set with UTF-8 Fail\n");
+ }
+ response.setCharacterEncoding((String)null);
+ if ((defaultEncoding == null && response.getCharacterEncoding() == null) ||
+ defaultEncoding != null && defaultEncoding.equalsIgnoreCase(response.getCharacterEncoding())) {
+ report.append(" Set with null Pass\n");
+ } else {
+ pass = false;
+ report.append(" Set with null Fail\n");
+ }
+ response.reset();
+
+ report.append("Test 2: Content-Type UTF-8 then null:\n");
+ response.setContentType("text/plain; charset=UTF-8");
+ if ("UTF-8".equalsIgnoreCase(response.getCharacterEncoding())) {
+ report.append(" Set via Content-Type Pass\n");
+ } else {
+ pass = false;
+ report.append(" Set via Content-Type Fail\n");
+ }
+ response.setCharacterEncoding((String)null);
+ if ((defaultEncoding == null && response.getCharacterEncoding() == null) ||
+ defaultEncoding != null && defaultEncoding.equalsIgnoreCase(response.getCharacterEncoding())) {
+ report.append(" Set with null Pass\n");
+ } else {
+ pass = false;
+ report.append(" Set with null Fail\n");
+ }
+ response.reset();
+
+ report.append("Test 3: Locale Shift_Jis then null:\n");
+ response.setLocale(new Locale("ja"));
+ if ("Shift_Jis".equalsIgnoreCase(response.getCharacterEncoding())) {
+ report.append(" Set via Locale Pass\n");
+ } else {
+ pass = false;
+ report.append(" Set via Locale Fail\n");
+ }
+ response.setCharacterEncoding((String)null);
+ if ((defaultEncoding == null && response.getCharacterEncoding() == null) ||
+ defaultEncoding != null && defaultEncoding.equalsIgnoreCase(response.getCharacterEncoding())) {
+ report.append(" Set with null Pass\n");
+ } else {
+ pass = false;
+ report.append(" Set with null Fail\n");
+ }
+ response.reset();
+
+ report.append("Test 4: Invalid then getWriter():\n");
+ response.setCharacterEncoding("does-not-exist");
+ if ("does-not-exist".equalsIgnoreCase(response.getCharacterEncoding())) {
+ report.append(" Set with invalid Pass\n");
+ } else {
+ pass = false;
+ report.append(" Set with invalid Fail\n");
+ }
+ try {
+ response.getWriter();
+ pass = false;
+ report.append(" getWriter() did not throw UnsupportedEncodingException Fail\n");
+ } catch (UnsupportedEncodingException uee) {
+ report.append(" getWriter() throw UnsupportedEncodingException Pass\n");
+ }
+ response.reset();
+
+ report.append("Test 5: Check getContentType():\n");
+ final String ENCODING = "ISO-8859-7";
+ response.setContentType("text/html");
+ response.setCharacterEncoding(ENCODING);
+ String type = response.getContentType();
+
+ if (type != null) {
+ if ((type.toLowerCase().indexOf("text/html") > -1)
+ && (type.toLowerCase().indexOf("charset") > -1)
+ && (type.toLowerCase().indexOf("iso-8859-7") > -1)) {
+ report.append(" getContentType returns correct type\n");
+ } else {
+ pass = false;
+ report.append(" Expecting text/html; charset=ISO-8859-7");
+ report.append(" getContentType returns incorrect type: " + type);
+ }
+ } else {
+ pass = false;
+ report.append(" getContentType return null");
+ }
+
+ PrintWriter pw = response.getWriter();
+ pw.print(report.toString());
+ ServletTestUtil.printResult(pw, pass);
+ }
+
+ public static void getWriterTest(ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+ boolean pass = false;
+
+ PrintWriter pw = response.getWriter();
+ response.setContentType("text/html;charset=ISO-8859-7");
+ String type = response.getContentType();
+ if (type != null) {
+ if ((type.toLowerCase().indexOf("text/html") > -1)
+ && (type.toLowerCase().indexOf("charset") > -1)
+ && (type.toLowerCase().indexOf("iso-8859-1") > -1)) {
+ pass = true;
+ } else {
+ pw.println("Expecting text/html; charset=ISO-8859-1");
+ pw.println("getContentType returns incorrect type: " + type);
+ }
+ } else {
+ pw.println("getContentType return null");
+ }
+ ServletTestUtil.printResult(pw, pass);
+ }
+
+ public static void getWriterFlushTest(ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+ boolean passed = false;
+ PrintWriter pw = response.getWriter();
+ response.setContentType("text/html;charset=ISO-8859-7");
+ pw.println("in test");
+ pw.flush();
+ if (response.isCommitted()) {
+ passed = true;
+ } else {
+ passed = false;
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getWriterAfterTest(ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+ boolean pass = false;
+ response.setContentType("text/xml;charset=ISO-8859-7");
+ PrintWriter pw = response.getWriter();
+ response.setContentType("text/html;charset=UTF-8");
+
+ String type = response.getContentType();
+ if (type != null) {
+ if ((type.toLowerCase().indexOf("text/html") > -1)
+ && (type.toLowerCase().indexOf("charset") > -1)
+ && (type.toLowerCase().indexOf("iso-8859-7") > -1)) {
+ pass = true;
+ } else {
+ pw.println("Expecting text/html; charset=ISO-8859-7");
+ pw.println("getContentType returns incorrect type: " + type);
+ }
+ } else {
+ pw.println("getContentType return null");
+ }
+ ServletTestUtil.printResult(pw, pass);
+ }
+
+ public static void getWriterIllegalStateExceptionTest(ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+
+ boolean passed = false;
+ ServletOutputStream sos = response.getOutputStream();
+
+ try {
+ PrintWriter pw = response.getWriter();
+ passed = false;
+ sos.println("getWriter() did not throw IllegalStateException ");
+ } catch (Throwable t) {
+ if (t instanceof IllegalStateException) {
+ passed = true;
+ } else {
+ passed = false;
+ sos.println(
+ "Exception thrown, but was not an instance of IllegalStateException.");
+ sos.println("instead received: " + t.getClass().getName());
+ }
+ }
+ ServletTestUtil.printResult(sos, passed);
+ }
+
+ public static void isCommittedTest(ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+
+ boolean passed = false;
+ ServletOutputStream sos = null;
+
+ try {
+ boolean notYet = false;
+ sos = response.getOutputStream();
+ // set buffer size
+ response.setBufferSize(50);
+
+ // commit the response
+ if (response.isCommitted() == false)
+ notYet = true;
+
+ response.flushBuffer();
+
+ if (notYet && (response.isCommitted() == true)) {
+ passed = true;
+ } else {
+ passed = false;
+ sos.println(
+ "IsCommitted did not detect that flushBuffer was called already");
+ }
+ } catch (Throwable t) {
+ throw new ServletException(t);
+ }
+ ServletTestUtil.printResult(sos, true);
+ }
+
+ public static void resetTest(ServletRequest request, ServletResponse response)
+ throws ServletException, IOException {
+
+ ServletOutputStream sos = null;
+
+ try {
+ sos = response.getOutputStream();
+
+ // set buffer size
+ response.setBufferSize(Data.FAILED.length() * 2);
+
+ // Write some data to the stream
+ ServletTestUtil.printResult(sos, false);
+
+ // Reset the response
+ response.reset();
+ ServletTestUtil.printResult(sos, true);
+ } catch (Throwable t) {
+ throw new ServletException(t);
+ }
+ }
+
+ public static void resetTest1(ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+ ServletOutputStream sos = null;
+
+ String ct = "application/java-archive";
+ String enc = "Shift_Jis";
+
+ response.setLocale(new Locale("ja"));
+ response.setCharacterEncoding(enc);
+ response.setContentType(ct);
+
+ try {
+ sos = response.getOutputStream();
+
+ // Write some data to the stream
+ sos.println("BigNoNo");
+ sos.println("Test FAILED");
+
+ // Reset the response
+ response.reset();
+
+ // Write something else to the stream
+ sos.println("YesPlease");
+ sos.println("Test PASSED");
+
+ response.flushBuffer();
+ } catch (Throwable t) {
+ throw new ServletException(t);
+ }
+ }
+
+ public static void resetIllegalStateExceptionTest(ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+
+ boolean passed = false;
+ PrintWriter pw = response.getWriter();
+ response.setBufferSize(11);
+ pw.println("in test");
+ response.flushBuffer();
+
+ try {
+ response.reset();
+ passed = false;
+ pw.println("reset() did not throw IllegalStateException ");
+ } catch (Throwable t) {
+ if (t instanceof IllegalStateException) {
+ passed = true;
+ } else {
+ passed = false;
+ pw.println(
+ "Exception thrown, but was not an instance of IllegalStateException.");
+ pw.println("instead received: " + t.getClass().getName());
+ }
+ }
+ ServletTestUtil.printResult(pw, true);
+ }
+
+ public static void getCharacterEncodingDefaultTest(ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+
+ final String ENCODING = "ISO-8859-1";
+ boolean passed = false;
+
+ PrintWriter pw = response.getWriter();
+
+ String result = response.getCharacterEncoding();
+
+ if (result != null) {
+ if (result.equalsIgnoreCase(ENCODING)) {
+ passed = true;
+ } else {
+ passed = false;
+ pw.println("getCharacterEncoding() returned an incorrect result ");
+ pw.println("Expected result = " + ENCODING);
+ pw.println("Actual result = |" + result + "|");
+ }
+ } else {
+ passed = false;
+ pw.println("getCharacterEncoding() returned a null result ");
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getCharacterEncodingTest(ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+
+ boolean passed = false;
+ final String ENCODING = "ISO-8859-7";
+ response.setCharacterEncoding(ENCODING);
+
+ PrintWriter pw = response.getWriter();
+
+ String result = response.getCharacterEncoding();
+ if (result != null) {
+ if (result.equalsIgnoreCase(ENCODING)) {
+ passed = true;
+ } else {
+ passed = false;
+ pw.println("getCharacterEncoding() returned an incorrect result ");
+ pw.println("Expected result = " + ENCODING);
+ pw.println("Actual result = |" + result + "|");
+ }
+ } else {
+ passed = false;
+ pw.println("getCharacterEncoding() returned a null result ");
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void setBufferSizeTest(ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+ boolean passed = false;
+ PrintWriter pw = response.getWriter();
+ response.setBufferSize(1000);
+ int result = response.getBufferSize();
+ // needs to be greater than or equal to SetBufferSize value or zero
+ if ((result >= 1000) || (result == 0)) {
+ passed = true;
+ } else {
+ passed = false;
+ pw.println("getBufferSize() returned incorrect result ");
+ pw.println("Expected result -> >= 1000 or 0");
+ pw.println("Actual result = |" + result + "|");
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void setBufferSizeIllegalStateExceptionTest(
+ ServletRequest request, ServletResponse response)
+ throws ServletException, IOException {
+
+ ServletOutputStream sos = null;
+ boolean passed = false;
+
+ try {
+ sos = response.getOutputStream();
+ sos.println("in test");
+ sos.flush();
+
+ try {
+ // should IllegalStateException
+ response.setBufferSize(20);
+ passed = false;
+ sos.println(
+ "setBufferSize(20) should have thrown IllegalStateException ");
+ } catch (Throwable t) {
+ if (t instanceof IllegalStateException) {
+ passed = true;
+ } else {
+ passed = false;
+ sos.println(
+ "Exception thrown, but was not an instance of IllegalStateException.");
+ sos.println("instead received: " + t.getClass().getName());
+ }
+ }
+ } catch (Throwable t) {
+ throw new ServletException(t);
+ }
+ ServletTestUtil.printResult(sos, passed);
+ }
+
+ public static void setContentLengthTest(ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+
+ String expected = "text/html";
+ response.setContentType(expected);
+ ServletOutputStream sos = response.getOutputStream();
+
+ response.setContentLength(Data.PASSED.length());
+ sos.print(Data.PASSED);
+
+ }
+
+ public static void setContentTypeTest(ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+ response.setContentType("text/html");
+ }
+
+ public static void setContentType1Test(ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+ boolean passed = false;
+ String expected = "text/html";
+ response.setContentType(expected);
+
+ String actual = response.getContentType();
+ PrintWriter pw = response.getWriter();
+ if (actual != null) {
+ if (actual.toLowerCase().indexOf(expected) >= 0) {
+ passed = true;
+ } else {
+ pw.println(
+ "The value returned by getContentType() did not contain the expected result="
+ + expected);
+ pw.println("actual=" + actual);
+ }
+ } else {
+ pw.println("Null value returned by getContentType() ");
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void setContentType2Test(ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+ String expected = "text/html";
+ String unexpected = "text/plain";
+
+ response.setContentType(expected);
+ ServletOutputStream sos = response.getOutputStream();
+ sos.println(response.getContentType() + "returned by getContentType()");
+ sos.flush();
+
+ response.setContentType(unexpected);
+ sos.println(response.getContentType() + "returned by getContentType()");
+ sos.flush();
+ }
+
+ public static void getContentTypeTest(ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+
+ boolean passed = false;
+ PrintWriter pw = response.getWriter();
+
+ String expected = "text/html";
+ response.setContentType(expected);
+
+ String actual = response.getContentType();
+ if (actual == null) {
+ pw.println("null value returned by getContentType()");
+ } else if (actual.toLowerCase().indexOf(expected) >= 0) {
+ passed = true;
+ } else {
+ passed = false;
+ pw.println(
+ "The value returned by getContentType() did not contain the expected result="
+ + expected);
+ pw.println("actual=" + actual);
+ }
+ ServletTestUtil.printResult(pw, passed);
+
+ }
+
+ public static void getContentType1Test(ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+
+ boolean passed = false;
+ String expected = "text/html";
+ response.setContentType(expected);
+ ServletOutputStream sos = response.getOutputStream();
+
+ String actual = response.getContentType();
+ if (actual == null) {
+ sos.println("null value returned by getContentType()");
+ } else if (actual.toLowerCase().indexOf(expected) >= 0) {
+ passed = true;
+ } else if (actual.toLowerCase().indexOf("char=") >= 0) {
+ sos.println(
+ "The value returned by getContentType() contains the unexpected encoding");
+ sos.println("actual=" + actual + " expected=" + expected);
+ } else {
+ sos.println(
+ "The value returned by getContentType() did not contain the expected result="
+ + expected);
+ sos.println("actual=" + actual);
+ }
+ ServletTestUtil.printResult(sos, passed);
+
+ }
+
+ public static void getContentTypeNullTest(ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+ PrintWriter pw = response.getWriter();
+ String actual = response.getContentType();
+
+ if (actual != null) {
+ pw.println("Test FAILED.");
+ pw.println("getContentType() did not return a null");
+ pw.println("actual=" + actual);
+ } else {
+ pw.println("Test PASSED");
+ }
+ }
+
+ public static void getContentTypeNull1Test(ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+ response.setCharacterEncoding("Shift_Jis");
+ String actual = response.getContentType();
+ PrintWriter pw = response.getWriter();
+
+ if (actual != null) {
+ pw.println("Test FAILED.");
+ pw.println("getContentType() did not return a null");
+ pw.println("actual=" + actual);
+ } else {
+ pw.println("Test PASSED");
+ }
+ }
+
+ public static void getContentTypeNull2Test(ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+ String expected = "Shift_Jis";
+
+ response.setContentType("text/html;charset=Shift_Jis");
+ response.setContentType("text/xml");
+ String actual_encoding = response.getCharacterEncoding();
+ String actual_type = response.getContentType();
+
+ PrintWriter pw = response.getWriter();
+
+ if (!actual_type.replace(" ", "")
+ .equalsIgnoreCase("text/xml;charset=Shift_Jis")) {
+ pw.println("getContentType() did not return text/xml; charset=Shift_Jis");
+ pw.println("actual=" + actual_type);
+ } else if (actual_encoding.toLowerCase()
+ .indexOf(expected.toLowerCase()) < 0) {
+ pw.println("getCharacterEncoding() did not return correct encoding");
+ pw.println("actual=" + actual_encoding);
+ pw.println("expected=" + expected);
+ } else {
+ pw.println("Test PASSED");
+ }
+ }
+
+ public static void setLocaleTest(ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+
+ Locale loc = new Locale("en", "US");
+ response.setLocale(loc);
+ response.getWriter().println("Arbitrary text");
+ }
+
+ public static void setLocale1Test(ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+ boolean passed = false;
+ String expected1 = "text/html";
+ String expected2 = "charset=Shift_Jis";
+ Locale loc = new Locale("ja");
+ response.setLocale(loc);
+ response.setContentType("text/html");
+
+ String actual = response.getContentType();
+ PrintWriter pw = response.getWriter();
+
+ if (actual == null) {
+ pw.println("Null value returned by getContentType()");
+ } else if ((actual.toLowerCase().indexOf(expected1) >= 0)
+ && (actual.toLowerCase().indexOf(expected2.toLowerCase()) >= 0)) {
+ passed = true;
+ } else {
+ pw.println(
+ "The value returned by getContentType() did not contain the expected result="
+ + expected1 + ";" + expected2);
+ pw.println("actual=" + actual);
+ }
+ ServletTestUtil.printResult(pw, passed);
+
+ }
+
+ public static void getLocaleDefaultTest(ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+ Locale defaultLocale = Locale.getDefault();
+ Locale containerLocale = response.getLocale();
+
+ PrintWriter pw = response.getWriter();
+ if (defaultLocale.equals(containerLocale)) {
+ pw.println("Test PASSED");
+ } else {
+ pw.println(
+ "Test FAILED. Expected ServletResponse.getLocale() to return the "
+ + "default locale of the VM if the locale was not explicily set.");
+ pw.println("VM default locale: " + defaultLocale);
+ pw.println(
+ "Locale returned by ServletResponse.getLocale(): " + containerLocale);
+ }
+
+ }
+
+ public static void getLocaleTest(ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+ boolean passed = false;
+ PrintWriter pw = response.getWriter();
+
+ Locale expectedResult = new Locale("en", "US");
+ response.setLocale(expectedResult);
+ Locale result = response.getLocale();
+
+ if (result.equals(expectedResult)) {
+ passed = true;
+ } else {
+ passed = false;
+ pw.println("getLocale() did not receive the proper locale");
+ pw.println("Expected result = " + expectedResult);
+ pw.println("Actual result = " + result);
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void resetBufferTest(ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+
+ ServletOutputStream sos = null;
+ try {
+ sos = response.getOutputStream();
+
+ // Write some data to the stream
+ response.setContentType("text/html");
+
+ ServletTestUtil.printResult(sos, false);
+ sos.println("resetBuffer() did not reset the buffer");
+ // Reset the response
+ response.resetBuffer();
+ ServletTestUtil.printResult(sos, true);
+ } catch (Throwable t) {
+ throw new ServletException(t);
+ }
+ }
+
+ // --------------------------- END ServletResponse
+ // -----------------------------
+
+ // ---------------------------- HttpServletResponse
+ // ----------------------------
+
+ public static void httpResponseWrapperConstructorTest(
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ PrintWriter pw = response.getWriter();
+ HttpServletResponseWrapper hsrw = new HttpServletResponseWrapper(response);
+ if (hsrw != null) {
+ ServletTestUtil.printResult(pw, true);
+ } else {
+ ServletTestUtil.printResult(pw, false);
+ }
+ }
+
+ public static void httpResponseWrapperGetResponseTest(
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ PrintWriter pw = response.getWriter();
+ boolean passed = false;
+ HttpServletResponseWrapper srw = new HttpServletResponseWrapper(response);
+ if (srw != null) {
+ ServletResponse sr = srw.getResponse();
+ if (!response.equals(sr)) {
+ passed = false;
+ pw.println("getResponse failed to return the same response object");
+ } else {
+ passed = true;
+ }
+ } else {
+ passed = false;
+ pw.println("constructor failed");
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void httpResponseWrapperSetResponseTest(
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ PrintWriter pw = response.getWriter();
+ boolean passed = true;
+ HttpServletResponseWrapper srw = new HttpServletResponseWrapper(response);
+ if (srw != null) {
+ try {
+ srw.setResponse(response);
+ } catch (Throwable t) {
+ passed = false;
+ pw.println("Error: setResponse generated a Throwable");
+ t.printStackTrace(pw);
+ }
+ if (passed) {
+ ServletResponse sr = srw.getResponse();
+ if (!response.equals(sr)) {
+ passed = false;
+ pw.println("getResponse failed to return the same response object");
+ }
+ }
+ } else {
+ passed = false;
+ pw.println("constructor failed");
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void httpResponseWrapperSetResponseIllegalArgumentExceptionTest(
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ PrintWriter pw = response.getWriter();
+ boolean passed = false;
+ HttpServletResponseWrapper srw = new HttpServletResponseWrapper(response);
+ if (srw != null) {
+ try {
+ srw.setResponse(null);
+ passed = false;
+ pw.println(
+ "Error: an IllegalArgumentException should have been generated");
+ } catch (Throwable t) {
+ if (t instanceof IllegalArgumentException) {
+ passed = true;
+ } else {
+ passed = false;
+ pw.println(
+ "Exception thrown, but was not an instance of IllegalArgumentException .");
+ pw.println("instead received: " + t.getClass().getName());
+ }
+ }
+ } else {
+ passed = false;
+ pw.println("constructor failed");
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void addCookieTest(HttpServletRequest request,
+ HttpServletResponse response) throws ServletException, IOException {
+
+ // check for this in the client side
+ response.addCookie(new Cookie("cookie1", "value1"));
+ response.addCookie(new Cookie("cookie2", "value2"));
+ }
+
+ public static void addDateHeaderTest(HttpServletRequest request,
+ HttpServletResponse response) throws ServletException, IOException {
+
+ long date = 9876543210L;
+ response.addDateHeader("DateInfo", date);
+ }
+
+ public static void addHeaderTest(HttpServletRequest request,
+ HttpServletResponse response) throws ServletException, IOException {
+
+ response.addHeader("header1", "value1");
+ response.addHeader("header1", "value11");
+ response.addHeader("header2", "value2");
+ }
+
+ public static void addIntHeaderTest(HttpServletRequest request,
+ HttpServletResponse response) throws ServletException, IOException {
+
+ response.addIntHeader("intHeader1", 1);
+ response.addIntHeader("intHeader1", 11);
+ response.addIntHeader("intHeader2", 2);
+ }
+
+ public static void containsHeaderTest(HttpServletRequest request,
+ HttpServletResponse response) throws ServletException, IOException {
+
+ boolean passed = true;
+ PrintWriter pw = response.getWriter();
+ pw.println("positive case");
+ String param = "header";
+ response.setHeader(param, "value1"); // set a Header
+ boolean expectedResult = true;
+ boolean result = response.containsHeader(param);
+
+ if (result != expectedResult) {
+ passed = false;
+ pw.println("HttpServletResponse.containsHeader(" + param
+ + ") returned incorrect results");
+ pw.println("Expected result = " + expectedResult);
+ pw.println("Actual result = |" + result);
+ }
+
+ pw.println("negative case");
+ param = "doesnotexist";
+ expectedResult = false;
+ result = response.containsHeader(param);
+
+ if (result != expectedResult) {
+ passed = false;
+ pw.println("HttpServletResponse.containsHeader(" + param
+ + ") gave incorrect results");
+ pw.println("Expected result = " + expectedResult);
+ pw.println("Actual result = |" + result);
+ }
+ ServletTestUtil.printResult(pw, passed);
+
+ }
+
+ public static void sendErrorClearBufferTest(HttpServletRequest request,
+ HttpServletResponse response) throws ServletException, IOException {
+
+ PrintWriter pw = response.getWriter();
+ pw.println("THIS TEXT SHOULD NOT APPEAR");
+ response.sendError(HttpServletResponse.SC_GONE);
+ }
+
+ public static void sendErrorIllegalStateExceptionTest(
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+ PrintWriter pw = response.getWriter();
+ pw.println("THIS TEXT SHOULD APPEAR");
+ response.flushBuffer();
+ try {
+ response.sendError(HttpServletResponse.SC_GONE);
+ passed = false;
+ pw.println("IllegalStateException exception should have been thrown");
+ } catch (Throwable t) {
+ if (t instanceof IllegalStateException) {
+ passed = true;
+ } else {
+ passed = false;
+ pw.println(
+ "Exception thrown, but was not an instance of IllegalStateException.");
+ pw.println("instead received: " + t.getClass().getName());
+ }
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void sendError_StringTest(HttpServletRequest request,
+ HttpServletResponse response) throws ServletException, IOException {
+
+ PrintWriter pw = response.getWriter();
+ pw.println("THIS TEXT SHOULD NOT APPEAR");
+ response.addHeader("header", "sendError_StringTest");
+ response.addCookie(new Cookie("cookie1", "value1"));
+ response.sendError(HttpServletResponse.SC_GONE,
+ "in sendError_StringTest servlet");
+ }
+
+ public static void sendError_StringIllegalStateExceptionTest(
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+ PrintWriter pw = response.getWriter();
+ pw.println("THIS TEXT SHOULD APPEAR");
+ response.flushBuffer();
+ try {
+ response.sendError(HttpServletResponse.SC_GONE,
+ "in sendError_StringIllegalStateExceptionTest servlet");
+ ServletTestUtil.printResult(pw, false);
+ pw.println("IllegalStateException exception should have been thrown");
+ } catch (Throwable t) {
+ if (t instanceof IllegalStateException) {
+ passed = true;
+ } else {
+ passed = false;
+ pw.println(
+ "Exception thrown, but was not an instance of IllegalStateException .");
+ pw.println("instead received: " + t.getClass().getName());
+ }
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void sendError_StringErrorPageTest(HttpServletRequest request,
+ HttpServletResponse response) throws ServletException, IOException {
+
+ PrintWriter pw = response.getWriter();
+ pw.println("THIS TEXT SHOULD NOT APPEAR");
+ response.addHeader("header", "sendError_StringTest");
+ response.addCookie(new Cookie("cookie1", "value1"));
+ response.sendError(HttpServletResponse.SC_LENGTH_REQUIRED,
+ "in sendError_StringErrorPageTest servlet");
+ }
+
+ public static void sendRedirectWithoutLeadingSlashTest(
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ response.sendRedirect("RedirectedTest");
+ }
+
+ public static void sendRedirectWithLeadingSlashTest(
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ response.sendRedirect("/RedirectedTest");
+ }
+
+ public static void sendRedirectIllegalStateExceptionTest(
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+ PrintWriter pw = response.getWriter();
+ response.setBufferSize(60);
+ response.setContentType("text/html");
+ pw.println("in sendRedirect_1Test servlet");
+ response.flushBuffer();
+
+ try {
+ response.sendRedirect("/RedirectedTest");
+ passed = false;
+ pw.println("IllegalStateException exception should have been thrown");
+ } catch (Throwable t) {
+ if (t instanceof IllegalStateException) {
+ passed = true;
+ } else {
+ passed = false;
+ pw.println(
+ "Exception thrown, but was not an instance of IllegalStateException .");
+ pw.println("instead received: " + t.getClass().getName());
+ }
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void setDateHeaderTest(HttpServletRequest request,
+ HttpServletResponse response) throws ServletException, IOException {
+
+ long date = 9876543210L;
+ response.setDateHeader("DateInfo", date);
+ }
+
+ public static void setDateHeaderOverrideTest(HttpServletRequest request,
+ HttpServletResponse response) throws ServletException, IOException {
+
+ long date = 9876543210L;
+ response.setDateHeader("DateInfo", date);
+ date = 9876544210L;
+ response.setDateHeader("DateInfo", date);
+ }
+
+ public static void setHeaderTest(HttpServletRequest request,
+ HttpServletResponse response) throws ServletException, IOException {
+ response.setHeader("header", "value1");
+ }
+
+ public static void setHeaderOverrideTest(HttpServletRequest request,
+ HttpServletResponse response) throws ServletException, IOException {
+ response.setHeader("header", "value1");
+ response.setHeader("header", "value2");
+ }
+
+ public static void setMultiHeaderTest(HttpServletRequest request,
+ HttpServletResponse response) throws ServletException, IOException {
+ response.setHeader("header", "value1");
+ response.addHeader("header", "value2");
+ response.setHeader("header", "value3");
+ }
+
+ public static void setIntHeaderTest(HttpServletRequest request,
+ HttpServletResponse response) throws ServletException, IOException {
+
+ response.addIntHeader("intHeader", 1);
+ response.setIntHeader("intHeader", 2);
+ }
+
+ public static void setStatusTest(HttpServletRequest request,
+ HttpServletResponse response) throws ServletException, IOException {
+
+ response.setStatus(HttpServletResponse.SC_OK);
+ }
+
+ public static void setStatusTest1(HttpServletRequest request,
+ HttpServletResponse response) throws ServletException, IOException {
+
+ response.setStatus(HttpServletResponse.SC_NOT_FOUND);
+ }
+
+ public static void getHeadersTest(HttpServletRequest request,
+ HttpServletResponse response) throws ServletException, IOException {
+ PrintWriter pw = response.getWriter();
+ Boolean passed = true;
+ String name = "TestheadersUnique";
+ String[] values = { "first", "second", "third" };
+
+ response.setHeader(name, values[0]);
+ response.addHeader(name, values[1]);
+ response.addHeader(name, values[2]);
+
+ Collection headers = response.getHeaders(name);
+
+ for (int i = 0; i < 3; i++) {
+ if (headers.contains(values[i])) {
+ headers.remove(values[i]);
+ } else {
+ passed = false;
+ pw.println("Header value " + values[i] + " is set but not present.");
+ }
+ }
+
+ if (!headers.isEmpty()) {
+ passed = false;
+ pw.println("Unexpected header value(s) is present:");
+ Iterator left = headers.iterator();
+ while (left.hasNext()) {
+ pw.println(left.next());
+ }
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getHeaderTest(HttpServletRequest request,
+ HttpServletResponse response) throws ServletException, IOException {
+ PrintWriter pw = response.getWriter();
+ Boolean passed = false;
+ String name = "TestheadersUnique";
+ String[] values = { "first", "second", "third" };
+
+ response.setHeader(name, values[0]);
+ response.addHeader(name, values[1]);
+ response.addHeader(name, values[2]);
+
+ String header = response.getHeader(name);
+
+ if (values[0].equals(header)) {
+ passed = true;
+ pw.println("Expected header value " + values[0] + " is set.");
+ } else {
+ pw.println("Test FAILED");
+ pw.println("Expected header value " + values[0] + " is not set.");
+ pw.println("but unexpected header " + header + " present.");
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getHeaderNamesTest(HttpServletRequest request,
+ HttpServletResponse response) throws ServletException, IOException {
+ PrintWriter pw = response.getWriter();
+ Boolean passed = true;
+ String[] names = { "TestheadersUnique", "TestheadersUniqueInt",
+ "TestheadersUniqueDate" };
+ String[] values = { "first", "second", "third" };
+ int[] values1 = { 1, 2, 3 };
+ long[] values2 = { 11L, 22L, 33L };
+
+ response.setHeader(names[0], values[0]);
+ response.addHeader(names[0], values[1]);
+ response.addHeader(names[0], values[2]);
+
+ response.setIntHeader(names[1], values1[0]);
+ response.addIntHeader(names[1], values1[1]);
+ response.addIntHeader(names[1], values1[2]);
+
+ response.setDateHeader(names[2], values2[0]);
+ response.addDateHeader(names[2], values2[1]);
+ response.addDateHeader(names[2], values2[2]);
+
+ Collection headers = response.getHeaderNames();
+
+ for (int i = 0; i < 3; i++) {
+ if (!headers.contains(names[i])) {
+ passed = false;
+ pw.println("Header name " + names[i] + " is set but not present.");
+ }
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getStatusTest(HttpServletRequest request,
+ HttpServletResponse response) throws ServletException, IOException {
+ Boolean passed = true;
+ PrintWriter pw = response.getWriter();
+
+ int[] status_codes = { HttpServletResponse.SC_ACCEPTED,
+ HttpServletResponse.SC_BAD_GATEWAY, HttpServletResponse.SC_BAD_REQUEST,
+ HttpServletResponse.SC_CONFLICT, HttpServletResponse.SC_CONTINUE,
+ HttpServletResponse.SC_CREATED,
+ HttpServletResponse.SC_EXPECTATION_FAILED,
+ HttpServletResponse.SC_FORBIDDEN, HttpServletResponse.SC_FOUND,
+ HttpServletResponse.SC_GATEWAY_TIMEOUT, HttpServletResponse.SC_GONE,
+ HttpServletResponse.SC_HTTP_VERSION_NOT_SUPPORTED,
+ HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
+ HttpServletResponse.SC_LENGTH_REQUIRED,
+ HttpServletResponse.SC_METHOD_NOT_ALLOWED,
+ HttpServletResponse.SC_MOVED_PERMANENTLY,
+ HttpServletResponse.SC_MOVED_TEMPORARILY,
+ HttpServletResponse.SC_MULTIPLE_CHOICES,
+ HttpServletResponse.SC_NO_CONTENT,
+ HttpServletResponse.SC_NON_AUTHORITATIVE_INFORMATION,
+ HttpServletResponse.SC_NOT_ACCEPTABLE, HttpServletResponse.SC_NOT_FOUND,
+ HttpServletResponse.SC_NOT_IMPLEMENTED,
+ HttpServletResponse.SC_NOT_MODIFIED, HttpServletResponse.SC_OK,
+ HttpServletResponse.SC_PARTIAL_CONTENT,
+ HttpServletResponse.SC_PAYMENT_REQUIRED,
+ HttpServletResponse.SC_PRECONDITION_FAILED,
+ HttpServletResponse.SC_PROXY_AUTHENTICATION_REQUIRED,
+ HttpServletResponse.SC_REQUEST_ENTITY_TOO_LARGE,
+ HttpServletResponse.SC_REQUEST_TIMEOUT,
+ HttpServletResponse.SC_REQUEST_URI_TOO_LONG,
+ HttpServletResponse.SC_REQUESTED_RANGE_NOT_SATISFIABLE,
+ HttpServletResponse.SC_RESET_CONTENT, HttpServletResponse.SC_SEE_OTHER,
+ HttpServletResponse.SC_SERVICE_UNAVAILABLE,
+ HttpServletResponse.SC_SWITCHING_PROTOCOLS,
+ HttpServletResponse.SC_TEMPORARY_REDIRECT,
+ HttpServletResponse.SC_UNAUTHORIZED,
+ HttpServletResponse.SC_UNSUPPORTED_MEDIA_TYPE,
+ HttpServletResponse.SC_USE_PROXY };
+
+ for (int i = 0; i < status_codes.length; i++) {
+ response.setStatus(status_codes[i]);
+ if (response.getStatus() != status_codes[i]) {
+ pw.println("Failed to set/getStatus " + status_codes[i]);
+ passed = false;
+ }
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+ // -------------------------- END HttpServletResponse
+ // --------------------------
+}
diff --git a/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/response/build.xml b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/response/build.xml
new file mode 100644
index 0000000000..1990a4a2fa
--- /dev/null
+++ b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/response/build.xml
@@ -0,0 +1,22 @@
+
+
+
+
+
diff --git a/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/response/validation/WebValidatorBase.java b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/response/validation/WebValidatorBase.java
new file mode 100644
index 0000000000..ef8941fe75
--- /dev/null
+++ b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/response/validation/WebValidatorBase.java
@@ -0,0 +1,634 @@
+/*
+ * Copyright (c) 2007, 2020 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/*
+ * $Id$
+ */
+
+package com.sun.ts.tests.servlet.common.response.validation;
+
+import com.sun.ts.tests.servlet.common.client.handler.Handler;
+import com.sun.ts.tests.servlet.common.client.handler.HandlerFactory;
+import com.sun.ts.tests.servlet.common.request.HttpRequest;
+import com.sun.ts.tests.servlet.common.request.HttpResponse;
+import com.sun.ts.tests.servlet.common.request.ValidationStrategy;
+import com.sun.ts.tests.servlet.common.request.WebTestCase;
+import org.apache.commons.httpclient.Header;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * Base abstract class for WebTestCase validation.
+ */
+public class WebValidatorBase implements ValidationStrategy {
+
+ private static final Logger logger = LoggerFactory.getLogger(WebValidatorBase.class);
+
+ /**
+ * Used to detect 4xx class HTTP errors to allow fail fast situations when 4xx
+ * errors are not expected.
+ */
+ protected static final char CLIENT_ERROR = '4';
+
+ /**
+ * Used to detect 5xx class HTTP errors to allows fail fast situations when
+ * 5xx errors are not expected.
+ */
+ protected static final char SERVER_ERROR = '5';
+
+ /**
+ * This test case's HttpResponse
+ */
+ protected HttpResponse _res = null;
+
+ /**
+ * This test case's HttpRequest
+ */
+ protected HttpRequest _req = null;
+
+ /**
+ * The test case being validated
+ */
+ protected WebTestCase _case = null;
+
+ /**
+ * validate Will validate the response against the configured
+ * TestCase.
+ *
+ *
+ *
+ * - Check the HTTP status-code
+ * - Check the HTTP reason-phrase
+ * - Check for expected headers
+ * - Check from unexpected headers
+ * - Check expected search strings
+ * - Check unexpected search strings
+ * - Check the goldenfile
+ *
+ */
+ public boolean validate(WebTestCase testCase) throws Exception {
+ _res = testCase.getResponse();
+ _req = testCase.getRequest();
+ _case = testCase;
+
+ // begin the check
+ try {
+ if (!checkStatusCode() || !checkReasonPhrase() || !checkExpectedHeaders()
+ || !checkUnexpectedHeaders() || !checkSearchStrings()
+ || !checkSearchStringsNoCase() || !checkUnorderedSearchStrings()
+ || !checkUnexpectedSearchStrings()) {
+ logger.error("Cannot validate response:" + testCase.getResponse());
+ return false;
+ }
+ } catch (IOException ioe) {
+ logger.error(" Unexpected Exception: " + ioe.getMessage(), ioe);
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * checkStatusCode will perform status code comparisons based on
+ * the algorithm below
+ *
+ * - Check the HTTP status code
+ *
+ * -
+ *
+ * If status code is -1, then return true
+ *
+ *
+ * -
+ *
+ * If test case status code null and response 4xx, return failure, print
+ * error; return false
+ *
+ *
+ * -
+ *
+ * If test case status code null and response 5xx, return failure include
+ * response body; return false
+ *
+ *
+ * -
+ *
+ * If test case status code null, and response not 4xx or 5xx, return true
+ *
+ *
+ * -
+ *
+ * Test case status code not null, compare it with the response status code;
+ * return true if equal
+ *
+ *
-
+ *
+ *
+ *
+ * @return boolen result of check
+ * @throws IOException
+ * if an IO error occurs during validation
+ */
+ protected boolean checkStatusCode() throws IOException {
+ String sCode = _case.getStatusCode();
+ String resCode = _res.getStatusCode();
+ if ("-1".equals(sCode))
+ return true;
+
+ if (sCode == null && resCode.charAt(0) == CLIENT_ERROR) {
+ logger.error("Test {} Unexpected {} received from target server! Request path: {}"
+ , _case.getName(), resCode, _req.getRequestPath());
+ return false;
+ }
+
+ if (sCode == null && (resCode.charAt(0) == SERVER_ERROR)) {
+ String resBody = _res.getResponseBodyAsRawString();
+ logger.error( " Test {} Unexpected '{}' received from target server!\n " +
+ "Error response received from server:\n" +
+ "------------------------------------------------\n" +
+ " {}"
+ , _case.getName(), resCode, (resBody != null ? resBody : "NO RESPONSE"));
+ return false;
+ }
+
+ if (sCode == null) {
+ return true;
+ }
+
+ /*
+ * Take sCode as a comma separated list of status codes.
+ *
+ * If prefixed by "!" the response status code must not match any in the list.
+ *
+ * Otherwise matching any in the list is accepted.
+ */
+
+ boolean exclusions = sCode.charAt(0) == '!';
+ String[] sCodes = exclusions ? sCode.substring(1).split(",") : sCode.split(",");
+
+ if (exclusions) {
+ for (String current : sCodes) {
+ if (current.equals(resCode)) {
+ logger.error(" Test {} Unexpected Status Code "
+ + "received from server. Expected any value except '{}', received '{}'",
+ _case.getName(), sCode, resCode);
+ return false;
+ }
+ }
+ } else {
+ boolean found = false;
+ for (String current : sCodes) {
+ if (current.equals(resCode)) {
+ logger.debug(" Test {} Expected Status Code '{}' found in response line!",
+ _case.getName(), current);
+ found = true;
+ break;
+ }
+ }
+
+ if (!found) {
+ logger.error(" Test {} Status Code '{}' not found in response line!",
+ _case.getName(), sCode);
+
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ /**
+ * checkSearchStrings will scan the response for the configured
+ * strings that are to be expected in the response.
+ *
+ * - Check search strings
+ *
+ * -
+ *
+ * If list of Strings is null, return true.
+ *
+ *
+ * -
+ *
+ * If list of Strings is not null, scan response body. If string is found,
+ * return true, otherwise display error and return false.
+ *
+ *
+ *
+ *
+ * NOTE: If there are multiple search strings, the search will be
+ * performed as such to preserve the order. For example, if the list of search
+ * strings contains two entities, the search for the second entity will be
+ * started after the index if the first match.
+ *
+ * @return boolen result of check
+ * @throws IOException
+ * if an IO error occurs during validation
+ */
+ protected boolean checkSearchStrings() throws Exception {
+ List list = _case.getSearchStrings();
+ boolean found = true;
+ if (list != null && !list.isEmpty()) {
+ String responseBody = _res.getResponseBodyAsRawString();
+
+ for (int i = 0, n = list.size(), startIdx = 0, bodyLength = responseBody
+ .length(); i < n; i++) {
+
+ // set the startIdx to the same value as the body length
+ // and let the test fail (prevents index based runtime
+ // exceptions).
+ if (startIdx >= bodyLength) {
+ startIdx = bodyLength;
+ }
+
+ String search = list.get(i);
+ int searchIdx = responseBody.indexOf(search, startIdx);
+
+ logger.debug(
+ " Test {} Scanning response for search string: '{}' starting at index location: {}",
+ _case.getName(), search, startIdx);
+ if (searchIdx < 0) {
+ found = false;
+ String sb = " Test %s Unable to find the following " +
+ "search string in the server's response: \n'%s'\n at index: %s" +
+ "\n Server's response:\n" +
+ "-------------------------------------------\n" +
+ "%s" +
+ "\n-------------------------------------------\n";
+ String result = String.format(sb, _case.getName(), search, startIdx, responseBody);
+ logger.error(result);
+ throw new Exception(result);
+ }
+
+ logger.debug(" Test {} Found search string: '{}' at index '{}' in the server's response",
+ _case.getName(), search, searchIdx);
+ // the new searchIdx is the old index plus the lenght of the
+ // search string.
+ startIdx = searchIdx + search.length();
+ }
+ }
+ return found;
+ }
+
+ /**
+ * checkSearchStringsNoCase will scan the response for the
+ * configured case insensitive strings that are to be expected in the
+ * response.
+ *
+ * - Check search strings
+ *
+ * -
+ *
+ * If list of Strings is null, return true.
+ *
+ *
+ * -
+ *
+ * If list of Strings is not null, scan response body. If string is found,
+ * return true, otherwise display error and return false.
+ *
+ *
+ *
+ *
+ * NOTE: If there are multiple search strings, the search will be
+ * performed as such to preserve the order. For example, if the list of search
+ * strings contains two entities, the search for the second entity will be
+ * started after the index if the first match.
+ *
+ * @return boolen result of check
+ * @throws IOException
+ * if an IO error occurs during validation
+ */
+ protected boolean checkSearchStringsNoCase() throws Exception {
+ List list = _case.getSearchStringsNoCase();
+ boolean found = true;
+ if (list != null && !list.isEmpty()) {
+ String responseBody = _res.getResponseBodyAsRawString();
+
+ for (int i = 0, n = list.size(), startIdx = 0, bodyLength = responseBody
+ .length(); i < n; i++) {
+
+ // set the startIdx to the same value as the body length
+ // and let the test fail (prevents index based runtime
+ // exceptions).
+ if (startIdx >= bodyLength) {
+ startIdx = bodyLength;
+ }
+
+ String search = list.get(i);
+ int searchIdx = responseBody.toLowerCase().indexOf(search.toLowerCase(),
+ startIdx);
+
+ logger.debug(
+ " Test {} Scanning response for search string: '{}' starting at index location: {}",
+ _case.getName(), search, startIdx);
+ if (searchIdx < 0) {
+ found = false;
+ String sb = " Test %s Unable to find the following search string in the server's " +
+ "response: \n'%s'\n at index: %s" +
+ "\n Server's response:\n" +
+ "-------------------------------------------\n" +
+ "%s" +
+ "\n-------------------------------------------\n";
+ String result = String.format(sb, _case.getName(), search, searchIdx, responseBody);
+ logger.error(result);
+ throw new Exception(result);
+ }
+
+ logger.debug(" Test {} Found search string: '{}' at index '{}' in the server's response",
+ _case.getName(), search, searchIdx);
+ // the new searchIdx is the old index plus the lenght of the
+ // search string.
+ startIdx = searchIdx + search.length();
+ }
+ }
+ return found;
+ }
+
+ /**
+ * checkUnorderedSearchStrings will scan the response for the
+ * configured strings that are to be expected in the response.
+ *
+ * - Check search strings
+ *
+ * -
+ *
+ * If list of Strings is null, return true.
+ *
+ *
+ * -
+ *
+ * If list of Strings is not null, scan response body. If string is found,
+ * return true, otherwise display error and return false.
+ *
+ *
+ *
+ *
+ *
+ * @return boolen result of check
+ * @throws IOException
+ * if an IO error occurs during validation
+ */
+ protected boolean checkUnorderedSearchStrings() throws Exception {
+ List list = _case.getUnorderedSearchStrings();
+ boolean found = true;
+ if (list != null && !list.isEmpty()) {
+ String responseBody = _res.getResponseBodyAsRawString();
+
+ for (String search : list) {
+ int searchIdx = responseBody.indexOf(search);
+ logger.debug(" Test {} Scanning response for search string: '{}'...",
+ _case.getName(), search);
+ if (searchIdx < 0) {
+ found = false;
+ String sb = " Test %s Unable to find the following " +
+ "search string in the server's " +
+ "response: \n' %s" +
+ "\n Server's response:\n" +
+ "-------------------------------------------\n" +
+ "%s" +
+ "\n-------------------------------------------\n";
+ String result = String.format(sb, _case.getName(), search, responseBody);
+ logger.error(result);
+ throw new Exception(result);
+ }
+
+ logger.debug(" Test {} Found search string: '{}' at index '{}' in the server's response",
+ _case.getName(), search, searchIdx);
+ }
+ }
+ return found;
+ }
+
+ /**
+ * checkUnexpectedSearchStrings will scan the response for the
+ * configured strings that are not expected in the response.
+ *
+ * - Check unexpected search strings
+ *
+ * -
+ *
+ * If list of Strings is null, return true.
+ *
+ *
+ * -
+ *
+ * If list of Strings is not null, scan response body. If string is not found,
+ * return true, otherwise display error and return false.
+ *
+ *
+ *
+ *
+ *
+ * @return boolen result of check
+ * @throws IOException
+ * if an IO error occurs during validation
+ */
+ protected boolean checkUnexpectedSearchStrings() throws IOException {
+ List list = _case.getUnexpectedSearchStrings();
+ if (list != null && !list.isEmpty()) {
+ String responseBody = _res.getResponseBodyAsRawString();
+ for (String search : list) {
+ logger.debug(" Test {} Scanning response. The following string should not be present in the response: '{}'",
+ _case.getName(), search);
+ if (responseBody.contains(search)) {
+ String sb = " Test {} Found the following unexpected " +
+ "search string in the server's " +
+ "response: '{}'" +
+ "\n Server's response:\n" +
+ "-------------------------------------------\n" +
+ "{}}" +
+ "\n-------------------------------------------\n";
+ logger.error(sb, _case.getName(), search, responseBody);
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+
+ /**
+ * checkReasonPhrase will perform comparisons between the
+ * configued reason-phrase and that of the response.
+ *
+ * - Check reason-phrase
+ *
+ * -
+ *
+ * If configured reason-phrase is null, return true.
+ *
+ *
+ * -
+ *
+ * If configured reason-phrase is not null, compare the reason-phrases with
+ * the response. If equal, return true, otherwise display error and return
+ * false.
+ *
+ *
+ *
+ *
+ *
+ * @return boolen result of check
+ */
+ protected boolean checkReasonPhrase() {
+ String sReason = _case.getReasonPhrase();
+ String resReason = _res.getReasonPhrase();
+
+ if (sReason == null) {
+ return true;
+ }
+ boolean check = sReason.equalsIgnoreCase(resReason);
+ if (check) {
+ logger.debug("Test {}, found expected reasonPhrase is '{}'",_case.getName(), resReason);
+ return true;
+ }
+ logger.error("Test {}, reasonPhrase is '{}' but not '{}'", _case.getName(), resReason, sReason);
+ return false;
+ }
+
+ /**
+ * checkExpectedHeaders will check the response for the
+ * configured expected headers.
+ *
+ * - Check expected headers
+ *
+ * -
+ *
+ * If there are no expected headers, return true.
+ *
+ *
+ * -
+ *
+ * If there are expected headers, scan the response for the expected headers.
+ * If all expected headers are found, return true, otherwise display an error
+ * and return false.
+ *
+ *
+ *
+ *
+ *
+ * @return boolen result of check
+ */
+ protected boolean checkExpectedHeaders() throws Exception {
+ Header[] expected = _case.getExpectedHeaders();
+ if (isEmpty(expected)) {
+ return true;
+ }
+ boolean found = true;
+ Header currentHeader = null;
+ for (Header header : expected) {
+ currentHeader = header;
+ Header resHeader = _res.getResponseHeader(currentHeader.getName());
+ if (resHeader != null) {
+ Handler handler = HandlerFactory.getHandler(currentHeader.getName());
+ if (!handler.invoke(currentHeader, resHeader)) {
+ found = false;
+ break;
+ }
+ } else {
+ found = false;
+ break;
+ }
+ }
+ if (!found) {
+ StringBuilder sb = new StringBuilder(255);
+ sb.append(" Test %s Unable to find the following header");
+ sb.append(" in the server's response: ");
+ sb.append("%s").append("\n");
+ sb.append(" Response headers received from");
+ sb.append(" server:");
+
+ Header[] resHeaders = _res.getResponseHeaders();
+ sb.append(Arrays.stream(resHeaders)
+ .map(header -> "ResponseHeader ->" + header.toExternalForm())
+ .collect(Collectors.joining("\n\t")));
+
+ sb.append("\n");
+ String result = String.format(sb.toString(), _case.getName(), currentHeader.toExternalForm());
+ logger.error(result);
+ throw new Exception(result);
+ }
+ logger.debug(" Test {} Found expected header: {}", _case.getName(), currentHeader.toExternalForm());
+ return true;
+ }
+
+ /**
+ * checkUnexpectedHeaders will check the response for the
+ * configured unexpected expected headers.
+ *
+ * - Check unexpected headers
+ *
+ * -
+ *
+ * If there are no configured unexpected headers, return true.
+ *
+ *
+ * -
+ *
+ * If there are configured unexpected headers, scan the response for the
+ * unexpected headers. If the headers are not found, return true, otherwise
+ * display an error and return false.
+ *
+ *
+ *
+ *
+ *
+ * @return boolen result of check
+ */
+ protected boolean checkUnexpectedHeaders() {
+ Header[] unexpected = _case.getUnexpectedHeaders();
+ if (isEmpty(unexpected)) {
+ return true;
+ } else {
+ for (Header currentHeader : unexpected) {
+ String currName = currentHeader.getName();
+ String currValue = currentHeader.getValue();
+ Header resHeader = _res.getResponseHeader(currName);
+ if (resHeader != null) {
+ if (resHeader.getValue().equals(currValue)) {
+ StringBuilder sb = new StringBuilder(255);
+ sb.append(" Test {} Unexpected header found in the ");
+ sb.append("server's response: ");
+ sb.append("{}").append("\n");
+ sb.append(" Response headers recieved from");
+ sb.append("server:");
+
+ Header[] resHeaders = _res.getResponseHeaders();
+ sb.append(Arrays.stream(resHeaders)
+ .map(header -> "ResponseHeader ->" + header.toExternalForm())
+ .collect(Collectors.joining("\n\t")));
+ logger.error(sb.toString(), _case.getName(), currentHeader.toExternalForm());
+
+ return false;
+ }
+ }
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Utility method to determine of the expected or unexpected headers are empty
+ * or not.
+ */
+ protected boolean isEmpty(Header[] headers) {
+ return headers == null || headers.length == 0;
+ }
+}
diff --git a/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/servlets/CommonServlets.java b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/servlets/CommonServlets.java
new file mode 100644
index 0000000000..a4a3e22afd
--- /dev/null
+++ b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/servlets/CommonServlets.java
@@ -0,0 +1,54 @@
+package com.sun.ts.tests.servlet.common.servlets;
+
+import com.sun.ts.tests.servlet.api.common.sharedfiles.HSessionAttributeListener;
+import com.sun.ts.tests.servlet.api.common.sharedfiles.HSessionListener;
+import com.sun.ts.tests.servlet.common.response.HttpResponseTestServlet;
+import com.sun.ts.tests.servlet.common.response.ResponseTestServlet;
+import com.sun.ts.tests.servlet.common.response.ResponseTests;
+import com.sun.ts.tests.servlet.common.util.Data;
+import com.sun.ts.tests.servlet.common.util.ServletTestUtil;
+import com.sun.ts.tests.servlet.common.util.StaticLog;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.jboss.shrinkwrap.resolver.api.maven.Maven;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class CommonServlets {
+
+ private static final CommonServlets INSTANCE = new CommonServlets();
+
+ private final JavaArchive[] javaArchives;
+
+ private CommonServlets() {
+ List archives = new ArrayList<>();
+
+ File[] files = Maven.configureResolver().workOffline().loadPomFromFile("pom.xml")
+ .resolve("org.slf4j:slf4j-simple")
+ .withTransitivity()
+ .asFile();
+ List slf4jJars =
+ Arrays.stream(files).map(file -> ShrinkWrap.createFromZipFile(JavaArchive.class, file))
+ .collect(Collectors.toList());
+
+ //archives.addAll(slf4jJars);
+
+ archives.add(ShrinkWrap.create(JavaArchive.class, "common-servlets.jar")
+ .addClasses(GenericCheckTestResultServlet.class, GenericTCKServlet.class, RequestTestServlet.class,
+ HttpCheckTestResultServlet.class, HttpRequestTestServlet.class, RequestTests.class,
+ HttpTCKServlet.class, Data.class, StaticLog.class, ServletTestUtil.class,
+ ResponseTests.class, ResponseTestServlet.class, HttpResponseTestServlet.class,
+ HSessionListener.class, HSessionAttributeListener.class));
+
+ javaArchives = archives.toArray(new JavaArchive[0]);
+ }
+
+ public static JavaArchive[] getCommonServletsArchive() {
+ return INSTANCE.javaArchives;
+ }
+
+}
diff --git a/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/servlets/GenericCheckTestResultServlet.java b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/servlets/GenericCheckTestResultServlet.java
new file mode 100644
index 0000000000..710e6a3f3b
--- /dev/null
+++ b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/servlets/GenericCheckTestResultServlet.java
@@ -0,0 +1,87 @@
+/*
+ *
+ * *
+ * * The Apache Software License, Version 1.1
+ * *
+ * * Copyright (c) 2018, 2020 Oracle and/or its affiliates. All rights reserved.
+ * * Copyright (c) 1999-2001 The Apache Software Foundation. All rights
+ * * reserved.
+ * *
+ * * Redistribution and use in source and binary forms, with or without
+ * * modification, are permitted provided that the following conditions
+ * * are met:
+ * *
+ * * 1. Redistributions of source code must retain the above copyright
+ * * notice, this list of conditions and the following disclaimer.
+ * *
+ * * 2. Redistributions in binary form must reproduce the above copyright
+ * * notice, this list of conditions and the following disclaimer in
+ * * the documentation and/or other materials provided with the
+ * * distribution.
+ * *
+ * * 3. The end-user documentation included with the redistribution, if
+ * * any, must include the following acknowlegement:
+ * * "This product includes software developed by the
+ * * Apache Software Foundation (http://www.apache.org/)."
+ * * Alternately, this acknowlegement may appear in the software itself,
+ * * if and wherever such third-party acknowlegements normally appear.
+ * *
+ * * 4. The names "The Jakarta Project", "Tomcat", and "Apache Software
+ * * Foundation" must not be used to endorse or promote products derived
+ * * from this software without prior written permission. For written
+ * * permission, please contact apache@apache.org.
+ * *
+ * * 5. Products derived from this software may not be called "Apache"
+ * * nor may "Apache" appear in their names without prior written
+ * * permission of the Apache Group.
+ * *
+ * * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
+ * * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
+ * * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ * * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * * SUCH DAMAGE.
+ * * ====================================================================
+ * *
+ * * This software consists of voluntary contributions made by many
+ * * individuals on behalf of the Apache Software Foundation. For more
+ * * information on the Apache Software Foundation, please see
+ * * TEST_HEADER is the constant for the testname
+ * header.
+ */
+ private static final String TEST_HEADER = "testname";
+
+ /**
+ * TEST_ARGS is an array of Classes used during reflection.
+ */
+ private static final Class[] TEST_ARGS = { ServletRequest.class,
+ ServletResponse.class };
+
+ /**
+ * init initializes the servlet.
+ *
+ * @param config
+ * - ServletConfig
+ */
+ public void init(ServletConfig config) throws ServletException {
+ super.init(config);
+ }
+
+ public void service(ServletRequest req, ServletResponse res)
+ throws ServletException, IOException {
+ invokeTest(req, res);
+ }
+
+ /**
+ * invokeTest uses reflection to invoke test methods in child
+ * classes of this particular class.
+ *
+ * @param req
+ * - ServletRequest
+ * @param res
+ * - ServletResponse
+ * @exception ServletException
+ * if an error occurs
+ */
+ protected void invokeTest(ServletRequest req, ServletResponse res)
+ throws ServletException {
+ String test = req.getParameter(TEST_HEADER);
+ try {
+ Method method = this.getClass().getMethod(test, TEST_ARGS);
+ method.invoke(this, new Object[] { req, res });
+ } catch (InvocationTargetException ite) {
+ throw new ServletException(ite.getTargetException());
+ } catch (NoSuchMethodException nsme) {
+ throw new ServletException("Test: " + test + " does not exist");
+ } catch (Throwable t) {
+ throw new ServletException("Error executing test: " + test, t);
+ }
+ }
+
+}// GenericTCKServlet
diff --git a/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/servlets/HttpCheckTestResultServlet.java b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/servlets/HttpCheckTestResultServlet.java
new file mode 100644
index 0000000000..29fc6430c4
--- /dev/null
+++ b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/servlets/HttpCheckTestResultServlet.java
@@ -0,0 +1,87 @@
+/*
+ *
+ * *
+ * * The Apache Software License, Version 1.1
+ * *
+ * * Copyright (c) 2007, 2020 Oracle and/or its affiliates. All rights reserved.
+ * * Copyright (c) 1999-2001 The Apache Software Foundation. All rights
+ * * reserved.
+ * *
+ * * Redistribution and use in source and binary forms, with or without
+ * * modification, are permitted provided that the following conditions
+ * * are met:
+ * *
+ * * 1. Redistributions of source code must retain the above copyright
+ * * notice, this list of conditions and the following disclaimer.
+ * *
+ * * 2. Redistributions in binary form must reproduce the above copyright
+ * * notice, this list of conditions and the following disclaimer in
+ * * the documentation and/or other materials provided with the
+ * * distribution.
+ * *
+ * * 3. The end-user documentation included with the redistribution, if
+ * * any, must include the following acknowlegement:
+ * * "This product includes software developed by the
+ * * Apache Software Foundation (http://www.apache.org/)."
+ * * Alternately, this acknowlegement may appear in the software itself,
+ * * if and wherever such third-party acknowlegements normally appear.
+ * *
+ * * 4. The names "The Jakarta Project", "Tomcat", and "Apache Software
+ * * Foundation" must not be used to endorse or promote products derived
+ * * from this software without prior written permission. For written
+ * * permission, please contact apache@apache.org.
+ * *
+ * * 5. Products derived from this software may not be called "Apache"
+ * * nor may "Apache" appear in their names without prior written
+ * * permission of the Apache Group.
+ * *
+ * * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
+ * * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
+ * * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ * * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * * SUCH DAMAGE.
+ * * ====================================================================
+ * *
+ * * This software consists of voluntary contributions made by many
+ * * individuals on behalf of the Apache Software Foundation. For more
+ * * information on the Apache Software Foundation, please see
+ * * TEST_HEADER is the constant for the testname
+ * header.
+ */
+ private static final String TEST_HEADER = "testname";
+
+ /**
+ * TEST_ARGS is an array of Classes used during reflection.
+ */
+ private static final Class[] TEST_ARGS = { HttpServletRequest.class,
+ HttpServletResponse.class };
+
+ /**
+ * init initializes the servlet.
+ *
+ * @param config
+ * - ServletConfig
+ */
+ public void init(ServletConfig config) throws ServletException {
+ super.init(config);
+ }
+
+ /**
+ * invokeTest uses reflection to invoke test methods in child
+ * classes of this particular class.
+ *
+ * @param req
+ * - HttpServletRequest
+ * @param res
+ * - HttpServletResponse
+ * @exception ServletException
+ * if an error occurs
+ */
+ protected void invokeTest(HttpServletRequest req, HttpServletResponse res)
+ throws ServletException {
+ res.setContentType(TEXT_PLAIN);
+ char[] temp = req.getParameter(TEST_HEADER).toCharArray();
+ temp[0] = Character.toLowerCase(temp[0]);
+ String test = new String(temp);
+
+ try {
+ Method method = this.getClass().getMethod(test, TEST_ARGS);
+ method.invoke(this, new Object[] { req, res });
+ } catch (InvocationTargetException ite) {
+ throw new ServletException(ite.getTargetException());
+ } catch (NoSuchMethodException nsme) {
+ throw new ServletException("Test: " + test + " does not exist");
+ } catch (Throwable t) {
+ throw new ServletException("Error executing test: " + test, t);
+ }
+ }
+
+ /**
+ * A basic implementation of the doGet method which will call
+ * invokeTest.
+ *
+ * @param req
+ * - HttpServletRequest
+ * @param res
+ * - HttpServletResponse
+ * @exception ServletException
+ * if an error occurs
+ * @exception IOException
+ * if an IO error occurs
+ */
+ public void doGet(HttpServletRequest req, HttpServletResponse res)
+ throws ServletException, IOException {
+ invokeTest(req, res);
+ }
+
+ /**
+ * A basic implementation of the doPost method which will call
+ * invokeTest.
+ *
+ * @param req
+ * - HttpServletRequest
+ * @param res
+ * - HttpServletResponse
+ * @exception ServletException
+ * if an error occurs
+ * @exception IOException
+ * if an IO error occurs
+ */
+ public void doPost(HttpServletRequest req, HttpServletResponse res)
+ throws ServletException, IOException {
+ invokeTest(req, res);
+ }
+
+}// HttpTCKServlet
diff --git a/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/servlets/RequestTestServlet.java b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/servlets/RequestTestServlet.java
new file mode 100644
index 0000000000..50f871c76f
--- /dev/null
+++ b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/servlets/RequestTestServlet.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2007, 2020 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/*
+ * $Id$
+ */
+
+/*
+ * $URL$ $LastChangedDate$
+ */
+
+package com.sun.ts.tests.servlet.common.servlets;
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+import jakarta.servlet.GenericServlet;
+import jakarta.servlet.ServletConfig;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.ServletRequest;
+import jakarta.servlet.ServletResponse;
+
+public class RequestTestServlet extends GenericServlet {
+
+ private static final String TEST_HEADER = "testname";
+
+ private static final Class[] TEST_ARGS = { PrintWriter.class,
+ ServletRequest.class, ServletResponse.class };
+
+ public void init(ServletConfig servletConfig) throws ServletException {
+ super.init(servletConfig);
+ }
+
+ public void service(ServletRequest servletRequest,
+ ServletResponse servletResponse) throws ServletException, IOException {
+ String test = servletRequest.getParameter(TEST_HEADER).trim();
+ try {
+ PrintWriter pw = servletResponse.getWriter();
+ Method method = RequestTests.class.getMethod(test, TEST_ARGS);
+ method.invoke(null, new Object[] { pw, servletRequest, servletResponse });
+ } catch (InvocationTargetException ite) {
+ throw new ServletException(ite.getTargetException());
+ } catch (NoSuchMethodException nsme) {
+ throw new ServletException("Test: " + test + " does not exist");
+ } catch (Throwable t) {
+ throw new ServletException("Error executing test: " + test, t);
+ }
+
+ }
+}
diff --git a/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/servlets/RequestTests.java b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/servlets/RequestTests.java
new file mode 100644
index 0000000000..b2a7762d1c
--- /dev/null
+++ b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/servlets/RequestTests.java
@@ -0,0 +1,2685 @@
+/*
+ * Copyright (c) 2007, 2020 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/*
+ * $Id$
+ */
+package com.sun.ts.tests.servlet.common.servlets;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.UnsupportedEncodingException;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.Arrays;
+import java.util.Enumeration;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Vector;
+
+import com.sun.ts.tests.servlet.common.util.Data;
+import com.sun.ts.tests.servlet.common.util.ServletTestUtil;
+
+import jakarta.servlet.RequestDispatcher;
+import jakarta.servlet.ServletContext;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.ServletInputStream;
+import jakarta.servlet.ServletRequest;
+import jakarta.servlet.ServletRequestWrapper;
+import jakarta.servlet.ServletResponse;
+import jakarta.servlet.http.Cookie;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletRequestWrapper;
+import jakarta.servlet.http.HttpServletResponse;
+import jakarta.servlet.http.HttpSession;
+
+public class RequestTests {
+
+ static String savedSessionId = null;
+
+ static String savedRequestedSessionId = null;
+
+ static HttpSession savedSession = null;
+
+ // ------------------------ jakarta_servlet.RequestRequest
+ // -------------------------------
+ public static void requestWrapperConstructorTest(PrintWriter pw,
+ ServletRequest request, ServletResponse response)
+ throws ServletException, IOException {
+ ServletRequestWrapper srw = new ServletRequestWrapper(request);
+ if (srw != null) {
+ ServletTestUtil.printResult(pw, true);
+ } else {
+ ServletTestUtil.printResult(pw, false);
+ }
+ }
+
+ public static void requestWrapperGetRequestTest(PrintWriter pw,
+ ServletRequest request, ServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+ ServletRequestWrapper srw = new ServletRequestWrapper(request);
+ if (srw != null) {
+ ServletRequest sr = srw.getRequest();
+ if (!request.equals(sr)) {
+ passed = false;
+ pw.println("getRequest failed to return the same request object");
+ } else {
+ passed = true;
+ }
+ } else {
+ passed = false;
+ pw.println("constructor returned a null");
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void requestWrapperSetRequestTest(PrintWriter pw,
+ ServletRequest request, ServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = true;
+ ServletRequestWrapper srw = new ServletRequestWrapper(request);
+ if (srw != null) {
+ try {
+ srw.setRequest(request);
+ } catch (Throwable t) {
+ passed = false;
+ pw.println("Error: setRequest generated a Throwable");
+ pw.println("Exception:" + t.getMessage());
+ }
+ if (passed) {
+ ServletRequest sr = srw.getRequest();
+ if (!request.equals(sr)) {
+ passed = false;
+ pw.println("getRequest failed to return the same request object");
+ }
+ }
+ } else {
+ passed = false;
+ pw.println("constructor returned a null");
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void requestWrapperSetRequestIllegalArgumentExceptionTest(
+ PrintWriter pw, ServletRequest request, ServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+ ServletRequestWrapper srw = new ServletRequestWrapper(request);
+ if (srw != null) {
+ try {
+ srw.setRequest(null);
+ passed = false;
+ pw.println(
+ "Error: an IllegalArgumentException should have been generated");
+ } catch (Throwable t) {
+ if (t instanceof IllegalArgumentException) {
+ passed = true;
+ } else {
+ passed = false;
+ pw.println(
+ "Exception thrown, but was not an instance of IllegalArgumentException.");
+ pw.println("instead received: " + t.getClass().getName());
+ }
+ }
+ } else {
+ passed = false;
+ pw.println("constructor returned a null");
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getAttributeNamesTest(PrintWriter pw,
+ ServletRequest request, ServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+ ;
+
+ Enumeration e = request.getAttributeNames();
+ Object[] attr = ServletTestUtil.getAsArray(e);
+ for (int i = 0, len = attr.length; i < len; i++) {
+ request.removeAttribute((String) attr[i]);
+ }
+
+ String attribute1 = "attribute1";
+ String attribute2 = "attribute2";
+
+ request.setAttribute(attribute1, "value1");
+ request.setAttribute(attribute2, "value2");
+ String[] expected = { attribute1, attribute2 };
+
+ e = request.getAttributeNames();
+
+ if (!ServletTestUtil.checkEnumeration(e, expected)) {
+ passed = false;
+ ServletTestUtil.printFailureData(pw, e, expected);
+ } else {
+ passed = true;
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getAttributeNamesEmptyEnumTest(PrintWriter pw,
+ ServletRequest request, ServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+
+ Enumeration e = request.getAttributeNames();
+ Object[] attr = ServletTestUtil.getAsArray(e);
+ for (int i = 0, len = attr.length; i < len; i++) {
+ request.removeAttribute((String) attr[i]);
+ }
+ e = request.getAttributeNames();
+ if (!e.hasMoreElements()) {
+ passed = true;
+ } else {
+ passed = false;
+ pw.println(
+ "getAttributeNames() returned a non empty enumeration after all attributes were removed");
+ pw.println("The values returned were:");
+ while (e.hasMoreElements()) {
+ pw.println(" " + (String) e.nextElement());
+ }
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getAttributeTest(PrintWriter pw, ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+
+ boolean passed = false;
+
+ request.setAttribute("attribute1", "value1");
+
+ Object o = request.getAttribute("attribute1");
+
+ if (o != null) {
+ if (o instanceof String) {
+ String attr = (String) o;
+ if (!attr.equals("value1")) {
+ passed = false;
+ pw.println("getAttribute() returned incorrect value");
+ pw.println("Expected Attribute Value -> value1");
+ pw.println("Actual Attribute value returned -> + attr ");
+ } else {
+ passed = true;
+ }
+ } else {
+ passed = false;
+ pw.println("getAttribute() returned an Object of type String");
+ }
+ } else {
+ passed = false;
+ pw.println("getAttribute() returned a null attribute");
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getAttributeDoesNotExistTest(PrintWriter pw,
+ ServletRequest request, ServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+
+ Object o = request.getAttribute("doesnotexist");
+
+ // No attribute was set. Expecting null value
+ if (o != null) {
+ passed = false;
+ pw.println("getAttribute() returned incorrect value");
+ pw.println("Expected Attribute Value -> null");
+ pw.println("Actual Attribute value returned -> + o ");
+ } else {
+ passed = true;
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getCharacterEncodingTest(PrintWriter pw,
+ ServletRequest request, ServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+
+ // getting char encoding
+ String expectedResult = "ISO-8859-1";
+ String encoding = request.getCharacterEncoding();
+
+ if (encoding != null) {
+ if (!encoding.equals(expectedResult)) {
+ passed = false;
+ pw.println(
+ "getCharacterEncoding() did not receive the proper encoding");
+ pw.println("Expected result = " + expectedResult);
+ pw.println("Actual result = |" + encoding + "|");
+
+ } else {
+ passed = true;
+ }
+
+ } else {
+ passed = false;
+ pw.println("getCharacterEncoding() returned a null result");
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getContentLengthTest(PrintWriter pw,
+ ServletRequest request, ServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+
+ // get the content length
+ int contentLength = request.getContentLength();
+
+ if (contentLength > 0) {
+ int len = 0;
+
+ // getting input stream
+ ServletInputStream sin = request.getInputStream();
+ // read from the stream
+ while (sin.read() != -1) {
+ len++;
+ }
+
+ // did we get what we wrote
+ if ((contentLength != len) && (contentLength != -1)) {
+ passed = false;
+ pw.println("getContentLength() method FAILED");
+ pw.println("Expected Value returned ->" + contentLength);
+ pw.println("Actual Value returned -> " + len);
+ } else {
+ passed = true;
+ }
+ } else {
+ passed = false;
+ pw.println("getContentLength() returned an incorrect length");
+ pw.println("Expected length = > 0");
+ pw.println("Actual length = " + contentLength);
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getContentTypeTest(PrintWriter pw, ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+
+ boolean passed = false;
+ String expectedResult = "text/plain";
+ String contentType = request.getContentType();
+
+ if (contentType != null) {
+ if (!expectedResult.equals(contentType)) {
+ passed = false;
+ pw.println("getContentType() did not receive the proper content type");
+ pw.println("Expected result=" + expectedResult);
+ pw.println("Actual result=" + contentType);
+ } else {
+ passed = true;
+ }
+ } else {
+ passed = false;
+ pw.println("getContentType() returned a null");
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getContentTypeNullTest(PrintWriter pw,
+ ServletRequest request, ServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+ String contentType = request.getContentType();
+
+ if (contentType != null) {
+ passed = false;
+ pw.println("getContentType() did not a return a null");
+ pw.println("Actual result=" + contentType);
+ } else {
+ passed = true;
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getInputStreamTest(PrintWriter pw, ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+
+ boolean passed = false;
+ String expected = "calling getInputStreamTest";
+
+ StringBuffer sb = new StringBuffer();
+
+ ServletInputStream sin = request.getInputStream();
+
+ int tmp = 0;
+ try {
+ tmp = sin.read();
+ while (tmp != -1) {
+ sb.append((char) tmp);
+ tmp = sin.read();
+ }
+ String actual = sb.toString();
+ if (actual != null) {
+ if (!actual.equals(expected)) {
+ passed = false;
+ pw.println("getInputStream returned the wrong body content");
+ pw.println("expected =" + expected);
+ pw.println("actual =" + actual);
+ } else {
+ passed = true;
+ }
+ } else {
+ passed = false;
+ pw.println("getInputStream returned null body content");
+ }
+ } catch (Throwable t) {
+ passed = false;
+ pw.println("read() generated an exception");
+ t.printStackTrace(pw);
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getInputStreamIllegalStateExceptionTest(PrintWriter pw,
+ ServletRequest request, ServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+
+ // getting Reader object
+ request.getReader();
+
+ try {
+ // we already got reader object
+ // IllegalStateException should be thrown
+ ServletInputStream sin = request.getInputStream();
+ passed = false;
+ pw.println(
+ "getInputStream should have thrown an IllegalStateException exception");
+ } catch (Throwable t) {
+ if (t instanceof IllegalStateException) {
+ passed = true;
+ } else {
+ passed = false;
+ pw.println(
+ "Exception thrown, but was not an instance of IllegalStateException .");
+ pw.println("instead received: " + t.getClass().getName());
+ }
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getLocaleTest(PrintWriter pw, ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+ boolean passed = false;
+ Locale expectedResult = new Locale("en", "US");
+ Locale actual = request.getLocale();
+
+ if (actual != null) {
+ if (!actual.equals(expectedResult)) {
+ passed = false;
+ pw.println("getLocale() did not receive the proper locale");
+ pw.println("Expected result = " + expectedResult.getLanguage() + "-"
+ + expectedResult.getCountry());
+ pw.println("Actual result = |" + actual.getLanguage() + "-"
+ + actual.getCountry() + "|");
+ } else {
+ passed = true;
+ }
+ } else {
+ passed = false;
+ pw.println("getLocale() returned a null result");
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getLocaleDefaultTest(PrintWriter pw,
+ ServletRequest request, ServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+
+ Locale actual = request.getLocale();
+
+ if (actual != null) {
+ if ((actual.getLanguage() == null) || (actual.getCountry() == null)) {
+ if (actual.getLanguage() == null) {
+ passed = false;
+ pw.println("Locale.getLanguage() returned a null");
+ }
+ if (actual.getCountry() == null) {
+ passed = false;
+ pw.println("Locale.getCountry() returned a null");
+ }
+ } else {
+ passed = true;
+ }
+ } else {
+ passed = false;
+ pw.println("getLocale() returned a null result");
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getLocalesDefaultTest(PrintWriter pw,
+ ServletRequest request, ServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+
+ Enumeration e = request.getLocales();
+
+ Object[] result = ServletTestUtil.getAsArray(e);
+ if (result.length == 1) {
+ Locale locale = ((Locale) result[0]);
+ if (locale != null) {
+ if ((locale.getLanguage() == null) || (locale.getCountry() == null)) {
+ if (locale.getLanguage() == null) {
+ passed = false;
+ pw.println("Locale.getLanguage() returned a null");
+ }
+ if (locale.getCountry() == null) {
+ passed = false;
+ pw.println("Locale.getCountry() returned a null");
+ }
+ } else {
+ passed = true;
+ }
+ } else {
+ passed = false;
+ pw.println("getLocales() returned a null result");
+ }
+ } else if (result.length <= 0) {
+ passed = false;
+ pw.println("getLocales() did not return any locales");
+ } else {
+ passed = false;
+ pw.println("getLocales() returned more than 1 locale");
+ pw.println("The locales received were :");
+
+ for (int i = 0; i < result.length; i++) {
+ pw.println(" " + ((Locale) result[i]).getLanguage() + "-"
+ + ((Locale) result[i]).getCountry());
+ }
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getLocalesTest(PrintWriter pw, ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+
+ boolean passed = true;
+
+ Enumeration e = request.getLocales();
+ Locale expectedResult1 = new Locale("en", "US");
+ boolean expectedResult1Found = false;
+ int expectedResult1order = 1;
+ Locale expectedResult2 = new Locale("en", "GB");
+ boolean expectedResult2Found = false;
+ int expectedResult2order = 2;
+ int expectedCount = 2;
+ int count = 0;
+
+ if (e.hasMoreElements()) {
+ Vector v = new Vector();
+
+ while (e.hasMoreElements()) {
+ Locale result = ((Locale) e.nextElement());
+
+ if (result.equals(expectedResult1)) {
+ if (!expectedResult1Found) {
+ count++;
+ expectedResult1Found = true;
+ if (count != expectedResult1order) {
+ passed = false;
+ pw.println(
+ "getLocales() did not return the locale in the correct order");
+ pw.println("expected order=" + expectedResult1order);
+ pw.println("actual order=" + count);
+ }
+ } else {
+ passed = false;
+ pw.println("getLocales() method return the same locale name twice");
+ pw.println("The locale already received was "
+ + expectedResult1.getLanguage() + "-"
+ + expectedResult1.getCountry());
+ }
+ } else if (result.equals(expectedResult2)) {
+ if (!expectedResult2Found) {
+ count++;
+ expectedResult2Found = true;
+ if (count != expectedResult2order) {
+ passed = false;
+ pw.println(
+ "getLocales() did not return the locale in the correct order");
+ pw.println("expected order=" + expectedResult2order);
+ pw.println("actual order=" + count);
+ }
+ } else {
+ passed = false;
+ pw.println("getLocales() method return the same locale name twice");
+ pw.println("The locale already received was "
+ + expectedResult2.getLanguage() + "-"
+ + expectedResult2.getCountry());
+ }
+ } else {
+ v.add(result);
+ }
+
+ }
+
+ if (count != expectedCount) {
+ passed = false;
+ pw.println("getLocales() did not return the proper number of locales");
+ pw.println("Expected count = " + expectedCount);
+ pw.println("Actual count = |" + count + "|");
+ pw.println("The expected locales received were :");
+
+ if (expectedResult1Found) {
+ pw.println(" " + expectedResult1.getLanguage() + "-"
+ + expectedResult1.getCountry());
+ }
+
+ if (expectedResult2Found) {
+ pw.println(" " + expectedResult2.getLanguage() + "-"
+ + expectedResult2.getCountry());
+ }
+
+ pw.println("Other locales received were :");
+
+ for (int i = 0; i < v.size(); i++) {
+ pw.println(" " + ((Locale) v.elementAt(i)).getLanguage() + "-"
+ + ((Locale) v.elementAt(i)).getCountry());
+ }
+ }
+ } else {
+ passed = false;
+ pw.println("getLocales() returned an empty enumeration");
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getParameterMapTest(PrintWriter pw, ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+
+ boolean passed = true;
+
+ Map map = request.getParameterMap();
+
+ int count = 0;
+ int expectedCount = 2;
+ String expectedResult1 = "parameter1";
+ String expectedResult1A = "value1";
+ int expectedCount1 = 1;
+ String expectedResult2 = "parameter2";
+ String expectedResult2A = "value2";
+ int expectedCount2 = 1;
+
+ if (map.containsKey(expectedResult1)) {
+ String result[] = (String[]) map.get(expectedResult1);
+ int count2 = result.length;
+
+ if (count2 == expectedCount1) {
+ if (result[0].equals(expectedResult1A)) {
+ count++;
+ } else {
+ passed = false;
+ pw.println(
+ "getParameterMap() did not return the proper value for the specified key");
+ pw.println("Expected result = " + expectedResult1A);
+ pw.println("Actual result = " + result[0]);
+ }
+ } else {
+ passed = false;
+ pw.println(
+ "Map.get() returned the wrong number of parameter values for key "
+ + expectedResult1);
+ pw.println("Expected number = " + expectedCount1);
+ pw.println("Actual number = " + count2);
+ }
+ }
+
+ if (map.containsKey(expectedResult2)) {
+ String result[] = (String[]) map.get(expectedResult2);
+ int count2 = result.length;
+
+ if (count2 == expectedCount1) {
+ if (result[0].equals(expectedResult2A)) {
+ count++;
+ } else {
+ passed = false;
+ pw.println(
+ "getParameterMap() did not return the proper value for the specified key");
+ pw.println("Expected result = " + expectedResult2A);
+ pw.println("Actual result = " + result[0]);
+ }
+ } else {
+ passed = false;
+ pw.println(
+ "Map.get() returned the wrong number of parameter values for key "
+ + expectedResult2);
+ pw.println("Expected number = " + expectedCount2);
+ pw.println("Actual number = " + count2);
+ }
+
+ }
+
+ if (count != expectedCount) {
+ passed = false;
+ pw.println("getParameterMap() return the proper keys and values ");
+ pw.println("Expected count = " + expectedCount);
+ pw.println("Actual count = |" + count + "|");
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getParameterNamesTest(PrintWriter pw,
+ ServletRequest request, ServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+
+ String parameter1 = "parameter1";
+ String parameter2 = "parameter2";
+
+ String[] expected = { parameter1, parameter2 };
+
+ Enumeration e = request.getParameterNames();
+
+ if (!ServletTestUtil.checkEnumeration(e, expected, false, false)) {
+ passed = false;
+ ServletTestUtil.printFailureData(pw, e, expected);
+ } else {
+ passed = true;
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getParameterNamesEmptyEnumTest(PrintWriter pw,
+ ServletRequest request, ServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+
+ // no parameter was set in the client side
+ Enumeration e = request.getParameterNames();
+
+ if (e.hasMoreElements()) {
+ passed = false;
+ pw.println(
+ "getParameterNames() return an enumerated list when it should have been empty");
+ pw.println("The list contains the following items:");
+ ServletTestUtil.getAsString(e);
+ } else {
+ passed = true;
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getParameterTest(PrintWriter pw, ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+
+ boolean passed = false;
+
+ // getting the request parameter
+ String param = "parameter1";
+ String actual = request.getParameter(param);
+ String expectedResult = "value1";
+
+ if (actual != null) {
+ // is param an instance of java.lang.String
+ if (!actual.equals(expectedResult)) {
+ passed = false;
+ pw.println("getParameter() did not return the correct value");
+ pw.println("Expected result = " + expectedResult);
+ pw.println("Actual result = |" + actual + "|");
+ } else {
+ passed = true;
+ }
+ } else {
+ passed = false;
+ pw.println("getParameter() did not return the correct value");
+ pw.println("Expected result = " + expectedResult);
+ pw.println("Actual result = |null|");
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getParameterValuesTest(PrintWriter pw,
+ ServletRequest request, ServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = true;
+
+ String[] names = request.getParameterValues("Names");
+ int enumlength = names.length;
+ String expectedResult1 = "value1";
+ String expectedResult2 = "value2";
+ boolean expectedResult1Found = false;
+ boolean expectedResult2Found = false;
+ int expectedCount = 2;
+ int count = 0;
+ int arraycount = 0;
+
+ if (enumlength > 0) {
+ Vector v = new Vector();
+
+ while (arraycount < enumlength) {
+ String result = names[arraycount++];
+
+ if (result.equals(expectedResult1)) {
+ if (!expectedResult1Found) {
+ count++;
+ expectedResult1Found = true;
+ } else {
+ passed = false;
+ pw.println("getParameterValues() return the same value twice ");
+ pw.println("The value already received was " + expectedResult1);
+ }
+ }
+
+ if (result.equals(expectedResult2)) {
+ if (!expectedResult2Found) {
+ count++;
+ expectedResult2Found = true;
+ } else {
+ passed = false;
+ pw.println("getParameterValues() return the same value twice ");
+ pw.println("The value already received was " + expectedResult2);
+ }
+ } else {
+ v.add(result);
+ }
+
+ }
+
+ if (count != expectedCount) {
+ passed = false;
+ pw.println(
+ "getParameterValues() did not return the proper number of parameter values");
+ pw.println("Expected count = " + expectedCount);
+ pw.println("Actual count = |" + count + "|");
+ pw.println("The expected parameter values received were :");
+
+ if (expectedResult1Found) {
+ pw.println(expectedResult1);
+ }
+
+ if (expectedResult2Found) {
+ pw.println(expectedResult2);
+ }
+
+ pw.println("Other parameter values received were :");
+
+ for (int i = 0; i < v.size(); i++) {
+ pw.println(" " + v.elementAt(i).toString());
+ }
+ }
+
+ } else {
+ passed = false;
+ pw.println("getParameterValues() returned an empty array");
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getParameterValuesDoesNotExistTest(PrintWriter pw,
+ ServletRequest request, ServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+
+ // no parameter was set with name zero
+
+ String[] vals = request.getParameterValues("doesnotexit");
+
+ if (vals != null) {
+ passed = false;
+ pw.println(
+ "getParameterValues() returned a null list of parameter values");
+ } else {
+ passed = true;
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getParameterDoesNotExistTest(PrintWriter pw,
+ ServletRequest request, ServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+
+ String expectedResult = null;
+ String actual = request.getParameter("doesnotexist");
+ // we are not settting any parameter in the client side so we should get
+ // null
+ if (actual != expectedResult) {
+ passed = false;
+ pw.println("getParameter() did not return the correct result");
+ pw.println("Expected result = " + expectedResult);
+ pw.println("Actual result = |" + actual + "|");
+ } else {
+ passed = true;
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getProtocolTest(PrintWriter pw, ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+
+ boolean passed = false;
+
+ String proto = request.getProtocol();
+ String expectedResult = "HTTP/1.";
+ // looking for HTTP
+ int actual = proto.indexOf(expectedResult);
+
+ if (actual == -1) {
+ passed = false;
+ pw.println("getProtocol() did not return the correct value");
+ pw.println("Expected result = " + expectedResult);
+ pw.println("Actual count = |" + proto + "|");
+ } else {
+ passed = true;
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getReaderTest(PrintWriter pw, ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+
+ boolean passed = false;
+ String expected = "calling getReaderTest";
+ BufferedReader br = request.getReader();
+
+ StringBuffer sb = new StringBuffer();
+
+ try {
+ String tmp = br.readLine();
+ while (tmp != null) {
+ sb.append(tmp);
+ tmp = br.readLine();
+ }
+ String actual = sb.toString();
+ if (actual != null) {
+ if (!actual.equals(expected)) {
+ passed = false;
+ pw.println("getReaderTest returned the wrong body content");
+ pw.println("expected =" + expected);
+ pw.println("actual =" + actual);
+ } else {
+ passed = true;
+ }
+ } else {
+ passed = false;
+ pw.println("getReaderTest returned null body content");
+ }
+ } catch (Throwable t) {
+ passed = false;
+ pw.println("readLine() generated an exception");
+ t.printStackTrace(pw);
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getReaderIllegalStateExceptionTest(PrintWriter pw,
+ ServletRequest request, ServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+
+ request.getInputStream();
+
+ try {
+ BufferedReader br = request.getReader();
+ passed = false;
+ pw.println("getReader() method did not throw IllegalStateException");
+ } catch (Throwable t) {
+ if (t instanceof IllegalStateException) {
+ passed = true;
+ } else {
+ passed = false;
+ pw.println(
+ "Exception thrown, but was not an instance of IllegalStateException.");
+ pw.println("instead received: " + t.getClass().getName());
+ }
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getReaderUnsupportedEncodingExceptionTest(PrintWriter pw,
+ ServletRequest request, ServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+
+ try {
+ BufferedReader br = request.getReader();
+ passed = false;
+ pw.println(
+ "getReader() method did not throw UnsupportedEncodingException");
+ } catch (Throwable t) {
+ if (t instanceof UnsupportedEncodingException) {
+ passed = true;
+ } else {
+ passed = false;
+ pw.println(
+ "Exception thrown, but was not an instance of java.io.UnsupportedEncodingException.");
+ pw.println("instead received: " + t.getClass().getName());
+ }
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getRemoteAddrTest(PrintWriter pw, ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+
+ boolean passed = false;
+
+ String expResult = request.getParameter("Address");
+ String[] expectedResults = ServletTestUtil.getAsArray(expResult);
+ Arrays.sort(expectedResults);
+ String actual = request.getRemoteAddr();
+
+ if (Arrays.binarySearch(expectedResults, actual) < 0) {
+ passed = false;
+ pw.println("getRemoteAddr() returned an incorrect result");
+ pw.println("Expected result = [ " + expResult + " ]");
+ pw.println("Actual result = |" + actual + "|");
+ } else {
+ passed = true;
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getLocalAddrTest(PrintWriter pw, ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+ boolean passed = false;
+
+ String expected_results = null;
+ InetAddress[] _addrs = null;
+
+ try {
+ _addrs = InetAddress
+ .getAllByName(InetAddress.getLocalHost().getCanonicalHostName());
+
+ if (_addrs.length != 0) {
+ StringBuffer sb = new StringBuffer(32);
+
+ for (int i = 0; i < _addrs.length; i++) {
+ String ip = _addrs[i].getHostAddress();
+ if (!ip.equals("127.0.0.1")) {
+ if (ip.contains("%")) {
+ int scope_id = ip.indexOf("%");
+ ip = ip.substring(0, scope_id);
+ }
+ sb.append(ip);
+ }
+ sb.append(",");
+ }
+ sb.append("127.0.0.1");
+ expected_results = sb.toString();
+ pw.println("Local Interface info: " + expected_results);
+ }
+
+ String[] expectedResults = ServletTestUtil.getAsArray(expected_results);
+ Arrays.sort(expectedResults);
+ String actual = request.getLocalAddr();
+
+ if (Arrays.binarySearch(expectedResults, actual) < 0) {
+ pw.println("getLocalAddr() returned an incorrect result");
+ pw.println("Expected result = [ " + expected_results + " ]");
+ pw.println("Actual result = |" + actual + "|");
+ } else {
+ passed = true;
+ }
+ } catch (UnknownHostException uhe) {
+ pw.println("Unable to obtain local host information.");
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getRemoteHostTest(PrintWriter pw, ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+
+ boolean passed = false;
+
+ String expResult = request.getParameter("Address");
+ String[] expectedResults = ServletTestUtil.getAsArray(expResult);
+ String actual = request.getRemoteHost();
+
+ for (int i = 0; i < expectedResults.length; i++) {
+ if (actual.indexOf(expectedResults[i]) >= 0) {
+ passed = true;
+ break;
+ }
+ }
+
+ if (passed == false) {
+ pw.println("getRemoteHost() returned an incorrect result");
+ pw.println("The expected result could be one of the following: [ "
+ + expResult + " ]");
+
+ pw.println("Actual result = |" + actual + "|");
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getRequestDispatcherTest(PrintWriter pw,
+ ServletRequest request, ServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+
+ String path = "/WEB-INF/web.xml";
+
+ RequestDispatcher rd = request.getRequestDispatcher(path);
+
+ if (rd == null) {
+ passed = false;
+ pw.println("getRequestDispatcher() returned a null");
+ } else {
+ passed = true;
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getSchemeTest(PrintWriter pw, ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+
+ boolean passed = false;
+
+ String expectedResult = "http";
+ // check for some value
+ String actual = request.getScheme();
+
+ if (actual != null) {
+ if (!actual.equals(expectedResult)) {
+ passed = false;
+ pw.println("getScheme() returned an incorrect result");
+ pw.println("Expected result = " + expectedResult);
+ pw.println("Actual result = |" + actual + "|");
+ } else {
+ passed = true;
+ }
+ } else {
+ passed = false;
+ pw.println("getScheme() returned a null");
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getServerNameTest(PrintWriter pw, ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+
+ boolean passed = false;
+
+ String actual = request.getServerName();
+ String expectedResult = null;
+ expectedResult = request.getParameter("hostname");
+
+ if (actual != null) {
+ if (expectedResult != null) {
+ InetAddress thisHost = null;
+ InetAddress expectedHost = null;
+ try {
+ thisHost = InetAddress.getByName(actual);
+ expectedHost = InetAddress.getByName(expectedResult);
+ } catch (Throwable t) {
+ throw new ServletException(
+ "Unexpected problem with Test: " + t.getMessage());
+ }
+
+ if (!thisHost.equals(expectedHost)) {
+ passed = false;
+ pw.println("getServerName() returned an incorrect result");
+ pw.println("Expected result (as IP) = " + expectedHost.toString());
+ pw.println("Actual result (as IP) = " + thisHost.toString());
+ } else {
+ passed = true;
+ }
+ } else {
+ passed = false;
+ pw.println("getParameter(hostname) returned a null result");
+ }
+
+ } else {
+ passed = false;
+ pw.println("getServerName() returned a null");
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getServerPortTest(PrintWriter pw, ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+
+ boolean passed = false;
+
+ String expectedResult = request.getParameter("port");
+ int actual = 0;
+ actual = request.getServerPort();
+
+ if (actual != 0) {
+ try {
+ int sexpectedResult = Integer.parseInt(expectedResult);
+ if (actual != sexpectedResult) {
+ passed = false;
+ pw.println("getServerPort() returned an incorrect result");
+ pw.println("Expected result = " + expectedResult);
+ pw.println("Actual result = |" + actual + "|");
+ } else {
+ passed = true;
+ }
+ } catch (Throwable t) {
+ passed = false;
+ t.printStackTrace(pw);
+ }
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void isSecureTest(PrintWriter pw, ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+
+ boolean passed = false;
+
+ // check for some value
+ boolean expectedResult = false;
+ boolean actual = request.isSecure();
+
+ if (actual != expectedResult) {
+ passed = false;
+ pw.println("isSecure() did not return the correct result");
+ pw.println("Expected result = " + expectedResult);
+ pw.println("Actual result = |" + actual + "|");
+ } else {
+ passed = true;
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void removeAttributeTest(PrintWriter pw, ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+
+ boolean passed = false;
+
+ request.setAttribute("attribute1", "value1");
+ request.removeAttribute("attribute1");
+ String attr = (String) request.getAttribute("attribute1");
+
+ if (attr != null) {
+ passed = false;
+ pw.println("removeAttribute() did not remove the indicated attribute");
+ } else {
+ passed = true;
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void setAttributeTest(PrintWriter pw, ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+
+ boolean passed = false;
+
+ String expectedResult = "value1";
+ request.setAttribute("attribute1", expectedResult);
+ String attr = (String) request.getAttribute("attribute1");
+
+ if (attr != null) {
+ if (!attr.equals(expectedResult)) {
+ passed = false;
+ pw.println("setAttribute() did not set the attribute properly");
+ pw.println("Expected result = " + expectedResult);
+ pw.println("Actual result = |" + attr + "|");
+ } else {
+ passed = true;
+ }
+ } else {
+ passed = false;
+ pw.println("setAttribute() did not set the attribute properly");
+ pw.println(
+ "An attempt to get the attribute resulted in a null being returned");
+
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getCharacterEncodingNullTest(PrintWriter pw,
+ ServletRequest request, ServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+
+ String actual = request.getCharacterEncoding();
+
+ if (actual != null) {
+ passed = false;
+ pw.println("getCharacterEncoding() returned the wrong result");
+ pw.println("Expected result = null");
+ pw.println("Actual result = |" + actual + "|");
+ } else {
+ passed = true;
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void setCharacterEncodingUnsupportedEncodingExceptionTest(
+ PrintWriter pw, ServletRequest request, ServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+
+ try {
+ request.setCharacterEncoding("doesnotexist");
+ passed = false;
+ pw.println(
+ "The exception UnsupportedEncodingException should have been thrown");
+ } catch (Throwable t) {
+ if (t instanceof UnsupportedEncodingException) {
+ passed = true;
+ } else {
+ passed = false;
+ pw.println(
+ "Exception thrown, but was not an instance of IllegalStateException.");
+ pw.println("instead received: " + t.getClass().getName());
+ }
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void setCharacterEncodingTest(PrintWriter pw,
+ ServletRequest request, ServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+ String expected = "ISO-8859-7";
+ try {
+ request.setCharacterEncoding(expected);
+ String encoding = request.getCharacterEncoding();
+
+ if (encoding != null) {
+ if (!encoding.equals(expected)) {
+ passed = false;
+ pw.println(
+ "getCharacterEncoding() did not receive the proper encoding");
+ pw.println("Expected result = " + expected);
+ pw.println("Actual result = |" + encoding + "|");
+ } else {
+ passed = true;
+ }
+ } else {
+ passed = false;
+ pw.println("getCharacterEncoding() returned a null result");
+ }
+ } catch (Throwable t) {
+ passed = false;
+ pw.println("Exception thrown:" + t.getClass().getName());
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void setCharacterEncodingTest1(PrintWriter pw,
+ ServletRequest request, ServletResponse response)
+ throws ServletException, IOException {
+ boolean passed = false;
+ String expected = "ISO-8859-7";
+
+ try {
+ BufferedReader br = request.getReader();
+ request.setCharacterEncoding(expected);
+ String encoding = request.getCharacterEncoding();
+
+ if (encoding == null) {
+ pw.println("getCharacterEncoding() returned null as expected");
+ passed = true;
+ } else {
+ pw.println(
+ "getCharacterEncoding() returned a non-null result: " + encoding);
+ }
+ } catch (Throwable t) {
+ pw.println("Exception thrown:" + t.getClass().getName());
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getLocalNameTest(PrintWriter pw, ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+ boolean passed = false;
+
+ String tmp = request.getLocalName();
+ String expected = request.getParameter("hostname");
+
+ if ((expected == null) || (tmp == null)) {
+ pw.println("Either answer or expected is null");
+ pw.println("Incorrect answer returned = " + tmp);
+ pw.println("Expecting " + expected);
+ } else {
+ tmp = tmp.toLowerCase();
+ // Check the cases when hostname and hostname.domain are used to send
+ // request
+ // Check the cases when localhost or 127.0.0.1 are used to send request
+ if (tmp.equals("localhost") || tmp.equals("127.0.0.1")
+ || tmp.startsWith(expected.toLowerCase())
+ || expected.toLowerCase().startsWith(tmp)
+ || expected.toLowerCase().equals("127.0.0.1")
+ || expected.toLowerCase().equals("localhost")) {
+ passed = true;
+ pw.println("Correct answer returned = " + tmp);
+ pw.println("Expecting " + expected);
+ } else {
+ // Checkthe case when ip address is used to send request
+ String thisHost = null;
+ String expectedHost = null;
+ try {
+ thisHost = InetAddress.getByName(tmp).getHostAddress();
+ expectedHost = InetAddress.getByName(expected).getHostAddress();
+
+ if (thisHost.equals(expected) || thisHost.equals(expectedHost)) {
+ pw.println("Test used an IP address to send request");
+ pw.println("Correct answer returned = " + tmp);
+ pw.println("Got result (as IP) = " + thisHost);
+ pw.println("expected " + expected);
+ pw.println("expected IP address " + expectedHost);
+ passed = true;
+ } else {
+ pw.println("getLocalName() returned an incorrect result");
+ pw.println("Expected result (as hostname) = " + expected);
+ pw.println("Expected result (as IP) = " + expectedHost);
+ pw.println("Got result (as IP) = " + thisHost);
+ pw.println("Incorrect answer returned = " + tmp);
+ }
+ } catch (java.net.UnknownHostException t) {
+ pw.println("Incorrect answer returned = " + tmp);
+ pw.println("Not an correct IP address neither");
+ pw.println("Expecting " + expected);
+ }
+ }
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getLocalPortTest(PrintWriter pw, ServletRequest request,
+ ServletResponse response) throws ServletException, IOException {
+ boolean passed = false;
+
+ int tmp = request.getLocalPort();
+
+ if (String.valueOf(tmp).equals(request.getParameter("hostport"))) {
+ passed = true;
+ pw.println("Correct answer returned = " + tmp);
+ } else {
+ pw.println("Incorrect answer returned = " + tmp);
+ pw.println("Expecting " + request.getParameter("hostport"));
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+ // --------------- END jakarta_servlet.ServletRequest
+ // ----------------------------
+
+ // --------------- jakarta_servlet_http.HttpServletRequest
+ // -----------------------
+ public static void httpRequestWrapperConstructorIllegalArgumentExceptionTest(
+ PrintWriter pw, HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ boolean passed = false;
+
+ try {
+ new HttpServletRequestWrapper(null);
+ passed = false;
+ pw.println("IllegalArgumentException should have been thrown");
+ } catch (Throwable t) {
+ if (t instanceof IllegalArgumentException) {
+ passed = true;
+ } else {
+ passed = false;
+ pw.println(
+ "Exception thrown, but was not an instance of IllegalArgumentException.");
+ pw.println("instead received: " + t.getClass().getName());
+ }
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void httpRequestWrapperConstructorTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ HttpServletRequestWrapper hsrw = new HttpServletRequestWrapper(request);
+ if (hsrw != null) {
+ ServletTestUtil.printResult(pw, true);
+ } else {
+ ServletTestUtil.printResult(pw, false);
+ }
+ }
+
+ public static void httpRequestWrapperGetRequestTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = true;
+ HttpServletRequestWrapper hsrw = new HttpServletRequestWrapper(request);
+ if (hsrw != null) {
+ ServletRequest sr = hsrw.getRequest();
+ if (!((ServletRequest) request).equals(sr)) {
+ passed = false;
+ pw.println("getRequest failed to return the same request object");
+ }
+ } else {
+ passed = false;
+ pw.println("constructor returned a null");
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void httpRequestWrapperSetRequestTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = true;
+ HttpServletRequestWrapper hsrw = new HttpServletRequestWrapper(request);
+ if (hsrw != null) {
+ try {
+ hsrw.setRequest(request);
+ } catch (Throwable t) {
+ passed = false;
+ pw.println("Error: setRequest generated a Throwable");
+ t.printStackTrace(pw);
+ }
+ if (passed) {
+ ServletRequest sr = hsrw.getRequest();
+ if (!((ServletRequest) request).equals(sr)) {
+ passed = false;
+ pw.println("getRequest failed to return the same request object");
+ }
+ }
+ } else {
+ passed = false;
+ pw.println("constructor returned a null");
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void httpRequestWrapperSetRequestIllegalArgumentExceptionTest(
+ PrintWriter pw, HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+ HttpServletRequestWrapper hsrw = new HttpServletRequestWrapper(request);
+ if (hsrw != null) {
+ try {
+ hsrw.setRequest(null);
+ passed = false;
+ pw.println(
+ "Error: an IllegalArgumentException should have been generated");
+ } catch (Throwable t) {
+ if (t instanceof IllegalArgumentException) {
+ passed = true;
+ } else {
+ passed = false;
+ pw.println(
+ "Exception thrown, but was not an instance of IllegalArgumentException.");
+ pw.println("instead received: " + t.getClass().getName());
+ }
+ }
+ } else {
+ passed = false;
+ pw.println("constructor returned a null");
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getAuthTypeWithoutProtectionTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+ String result = request.getAuthType();
+
+ if (result != null) {
+ passed = false;
+ pw.println(
+ "getAuthType() returned a non-null result, even though Servlet is not protected");
+ pw.println("Actual result = |" + result + "|");
+ } else {
+ passed = true;
+ }
+ ServletTestUtil.printResult(pw, passed);
+
+ }
+
+ public static void getContextPathTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+ String expectedResult = request.getHeader("result");
+ String result = request.getContextPath();
+
+ if (result != null) {
+ if (!result.equals(expectedResult)) {
+ passed = false;
+ pw.println("getContextPath() returned an incorrect result");
+ pw.println("Expected result = " + expectedResult);
+ pw.println("Actual result = |" + result + "|");
+ } else {
+ passed = true;
+ }
+ } else {
+ passed = false;
+ pw.println("getContextPath() returned a null result");
+ }
+ ServletTestUtil.printResult(pw, passed);
+
+ }
+
+ public static void getCookiesTest(PrintWriter pw, HttpServletRequest request,
+ HttpServletResponse response) throws ServletException, IOException {
+
+ boolean passed = true;
+ String expectedName = "cookie";
+ String expectedValue = "value";
+ boolean expectedResultFound = false;
+ Cookie cookies[] = null;
+ int count = 0;
+ int expectedCount = 1;
+ boolean gotCookie = false;
+ cookies = request.getCookies();
+ int len = cookies.length;
+
+ for (int i = 0; i < len; i++) {
+ String name = cookies[i].getName();
+ String value = cookies[i].getValue();
+ if (name.equals(expectedName) && value.equals(expectedValue)) {
+ if (!expectedResultFound) {
+ count++;
+ expectedResultFound = true;
+ } else {
+ passed = false;
+ pw.println("getCookies() method return the same cookie twice");
+ pw.println(
+ "The cookie already received was " + name + ", value=" + value);
+ }
+ } else {
+ passed = false;
+ pw.println("getCookies() method return the wrong cookie");
+ pw.println("actual=" + name + ", value=" + value);
+ }
+ }
+
+ if (count != expectedCount) {
+ passed = false;
+ pw.println(
+ "getCookies() method did not return the correct number of cookies");
+ pw.println("Expected count = " + expectedCount);
+ pw.println("Actual count = " + count);
+ }
+ ServletTestUtil.printResult(pw, passed);
+
+ }
+
+ public static void getCookiesNoCookiesTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ boolean passed = false;
+ Cookie[] cook = request.getCookies();
+
+ if (cook != null) {
+ passed = false;
+ pw.println(
+ "getCookies() returning non null value even though client is not sending any cookies.");
+ } else {
+ passed = true;
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getDateHeaderTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ boolean passed = true;
+
+ pw.println("lower case");
+ long expected = 946684801000L;
+ String param = "if-modified-since";
+ if (!testDateHeader(pw, request, expected, param)) {
+ passed = false;
+ }
+
+ pw.println("mix case");
+ param = "If-Modified-Since";
+ if (!testDateHeader(pw, request, expected, param)) {
+ passed = false;
+ }
+
+ pw.println("upper case");
+ param = "IF-MODIFIED-SINCE";
+ if (!testDateHeader(pw, request, expected, param)) {
+ passed = false;
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ private static boolean testDateHeader(PrintWriter pw,
+ HttpServletRequest request, long expected, String param) {
+ boolean passed = false;
+
+ try {
+ long result = request.getDateHeader(param);
+
+ if (result != expected) {
+ passed = false;
+ pw.println("getDateHeader(" + param + ") returned an incorrect result");
+ pw.println("Expected result = " + expected);
+ pw.println("Actual result = |" + result + "|");
+ } else {
+ passed = true;
+ }
+ } catch (Throwable t) {
+ passed = false;
+ pw.println("getDateHeader(" + param
+ + ") Can't convert the sent header value to Date");
+ pw.println("getDateHeader(" + param + ") threw exception");
+ t.printStackTrace(pw);
+ }
+ return passed;
+ }
+
+ public static void getDateHeaderNoHeaderTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+ long result = request.getDateHeader("If-Modified-Since");
+
+ if (result != -1) {
+ passed = false;
+ pw.println("getDateHeader didn't return -1 for a NonExistent header");
+ pw.println("Actual result = |" + result + "|");
+ } else {
+ passed = true;
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getDateHeaderIllegalArgumentExceptionTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+ String param = "If-Modified-Since";
+ try {
+ long result = request.getDateHeader("If-Modified-Since");
+ passed = false;
+ pw.println("getDateHeader(" + param
+ + ") did not throw an IllegalArgumentExcpetion");
+ } catch (Throwable t) {
+ if (t instanceof IllegalArgumentException) {
+ passed = true;
+ } else {
+ passed = false;
+ pw.println(
+ "Exception thrown, but was not an instance of IllegalArgumentException .");
+ pw.println("instead received: " + t.getClass().getName());
+ }
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getHeaderTest(PrintWriter pw, HttpServletRequest request,
+ HttpServletResponse response) throws ServletException, IOException {
+
+ boolean passed = true;
+
+ String expected = "Mozilla/4.0";
+
+ pw.println("lower case");
+ String param = "user-agent";
+ if (!testGetHeader(pw, request, expected, param)) {
+ passed = false;
+ }
+
+ pw.println("mixed case");
+ param = "User-Agent";
+ if (!testGetHeader(pw, request, expected, param)) {
+ passed = false;
+ }
+
+ pw.println("upper case");
+ param = "USER-AGENT";
+ if (!testGetHeader(pw, request, expected, param)) {
+ passed = false;
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ // This is a private utility test method
+ private static boolean testGetHeader(PrintWriter pw,
+ HttpServletRequest request, String expected, String param) {
+
+ boolean passed = false;
+
+ String result = request.getHeader(param);
+ if (!expected.equals(result)) {
+ passed = false;
+ pw.println("getHeader() returned an incorrect result");
+ pw.println("Expected result = " + expected);
+ pw.println("Actual result = |" + result + "|");
+ } else {
+ passed = true;
+ }
+ return passed;
+ }
+
+ public static void getHeaderNoHeaderTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+ String result = request.getHeader("doesnotexist");
+ if (result != null) {
+ passed = false;
+ pw.println("getHeader didn't return a null for a NonExistent header");
+ pw.println("Actual result = |" + result + "|");
+ } else {
+ passed = true;
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getHeaderNamesTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ boolean passed = true;
+
+ String expected1 = "If-Modified-Since";
+ String expected2 = "Cookie";
+ String[] expected = { expected1, expected2 };
+
+ Enumeration e = request.getHeaderNames();
+ if (e == null) {
+ // Some servlet containers won't allow servlets to use
+ // this method and in that case it returns null
+ } else {
+ if (!ServletTestUtil.checkEnumeration(e, expected, false, false)) {
+ passed = false;
+ ServletTestUtil.printFailureData(pw, e, expected);
+ }
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getHeadersTest(PrintWriter pw, HttpServletRequest request,
+ HttpServletResponse response) throws ServletException, IOException {
+
+ boolean passed = true;
+
+ final String[] expected = { "en-us, ga-us" };
+
+ final String[] expected1 = { "en-us", "ga-us" };
+
+ pw.println("lower case");
+ String param = "accept-language";
+ if (!testGetHeaders(pw, request, expected, param)) {
+ passed = testGetHeaders(pw, request, expected1, param);
+ }
+
+ pw.println("mixed case");
+ param = "Accept-Language";
+ if (!testGetHeaders(pw, request, expected, param)) {
+ passed = testGetHeaders(pw, request, expected1, param);
+ }
+
+ pw.println("upper case");
+ param = "ACCEPT-LANGUAGE";
+ if (!testGetHeaders(pw, request, expected, param)) {
+ passed = testGetHeaders(pw, request, expected1, param);
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ private static boolean testGetHeaders(PrintWriter pw,
+ HttpServletRequest request, String[] expected, String param) {
+
+ boolean passed = false;
+
+ Enumeration e = request.getHeaders(param);
+ if (e != null) {
+ if (!ServletTestUtil.checkEnumeration(e, expected)) {
+ passed = false;
+ ServletTestUtil.printFailureData(pw, e, expected);
+ } else {
+ passed = true;
+ }
+ } else {
+ passed = false;
+ pw.println("getHeaders(" + param + ") returned a null");
+ }
+ return passed;
+ }
+
+ public static void getHeadersNoHeadersTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ boolean passed = false;
+
+ Enumeration e = request.getHeaders("doesnotexist");
+
+ if (e.hasMoreElements()) {
+ passed = false;
+ pw.println("getHeaders(doesnotexist) returned a Non-Empty enumeration");
+ pw.print("The headers received were:");
+ ServletTestUtil.getAsString(e);
+ } else {
+ passed = true;
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getIntHeaderTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = true;
+ final int expected = 123;
+
+ pw.println("lower case");
+ String param = "myintheader";
+ if (!testGetIntHeader(pw, request, expected, param)) {
+ passed = false;
+ }
+
+ pw.println("mixed case");
+ param = "MyIntHeader";
+ if (!testGetIntHeader(pw, request, expected, param)) {
+ passed = false;
+ }
+ pw.println("upper case");
+ param = "MYINTHEADER";
+ if (!testGetIntHeader(pw, request, expected, param)) {
+ passed = false;
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ private static boolean testGetIntHeader(PrintWriter pw,
+ HttpServletRequest request, int expected, String param) {
+
+ boolean passed = false;
+
+ try {
+ int result = request.getIntHeader(param);
+
+ if (result != expected) {
+ passed = false;
+ pw.println("getIntHeader(" + param + ") return an incorrect result");
+ pw.println("Expected result = " + expected);
+ pw.println("Actual result = " + result);
+ } else {
+ passed = true;
+ }
+ } catch (Throwable t) {
+ passed = false;
+ pw.println("getIntHeader(" + param + ") generated an exception");
+ t.printStackTrace(pw);
+ }
+ return passed;
+ }
+
+ public static void getIntHeaderNumberFoundExceptionTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+
+ try {
+
+ String param = "MyNonIntHeader";
+ int result = request.getIntHeader(param);
+ passed = false;
+ pw.println("getIntHeader(" + param
+ + ") did not throw a NumberFormatException for a NonInt Header");
+ pw.println("Actual result = |" + result + "|");
+ } catch (Throwable t) {
+ if (t instanceof NumberFormatException) {
+ passed = true;
+ } else {
+ passed = false;
+ pw.println(
+ "Exception thrown, but was not an instance of NumberFormatException .");
+ pw.println("instead received: " + t.getClass().getName());
+ }
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getIntHeaderNoHeaderTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ boolean passed = false;
+ String param = "doesnotexist";
+
+ try {
+ int result = request.getIntHeader(param);
+
+ if (result != -1) {
+ passed = false;
+ pw.println("getIntHeader(" + param
+ + ") did not return a -1 for non-existent header");
+ pw.println("Actual result = |" + result + "|");
+ } else {
+ passed = true;
+ }
+
+ } catch (Throwable t) {
+ passed = false;
+ pw.println("getIntHeader(" + param
+ + ") generated an exception instead of returning -1");
+ t.printStackTrace(pw);
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getMethod_GETTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ boolean passed = false;
+
+ String expectedResult = "GET";
+ String result = request.getMethod();
+
+ if (result != null) {
+ if (!result.equalsIgnoreCase(expectedResult)) {
+ passed = false;
+ pw.println("getMethod() returned an incorrect result");
+ pw.println("Expected result = " + expectedResult);
+ pw.println("Actual result = |" + result + "|");
+ } else {
+ passed = true;
+ }
+ } else {
+ passed = false;
+ pw.println("getMethod() returned a null result");
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getMethod_HEADTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ String expectedResult = "HEAD";
+ String result = request.getMethod();
+ pw.write("Arbitrary Text");
+
+ if (result != null) {
+ if (result.equalsIgnoreCase(expectedResult)) {
+ response.addHeader("status", Data.PASSED);
+ } else {
+ response.addHeader("status", Data.FAILED);
+ }
+ }
+
+ }
+
+ public static void getMethod_POSTTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ boolean passed = false;
+ String expectedResult = "POST";
+ String result = request.getMethod();
+
+ if (result != null) {
+ if (!result.equalsIgnoreCase(expectedResult)) {
+ passed = false;
+ pw.println("getMethod() returned an incorrect result");
+ pw.println("Expected result = " + expectedResult);
+ pw.println("Actual result = |" + result + "|");
+ } else {
+ passed = true;
+ }
+ } else {
+ passed = false;
+ pw.println("getMethod() returned a null result");
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getPathInfoTest(PrintWriter pw, HttpServletRequest request,
+ HttpServletResponse response) throws ServletException, IOException {
+ boolean passed = false;
+ String expectedResult = "/pathinfostring1/pathinfostring2";
+ String result = request.getPathInfo();
+
+ if (result != null) {
+ if (!result.equals(expectedResult)) {
+ passed = false;
+ pw.println("getPathInfo() returned an incorrect result");
+ pw.println("Expected result = " + expectedResult);
+ pw.println("Actual result = |" + result + "|");
+ } else {
+ passed = true;
+ }
+ } else {
+ passed = false;
+ pw.println("getMethod() returned a null result");
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getPathInfoNullTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ boolean passed = false;
+ // shouldn't retrieve any extra path info coz nothing was provided
+ String result = request.getPathInfo();
+
+ if (result != null) {
+ passed = false;
+ pw.println("getPathInfo() returned a non-null result");
+ pw.println("Actual result = |" + result + "|");
+ } else {
+ passed = true;
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getPathTranslatedNullTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+
+ String result = request.getPathTranslated();
+
+ // null will be returned if running out of a jar
+ if (result != null) {
+ passed = false;
+ pw.println("getPathTranslated() returned an incorrect result");
+ pw.println("Expected result = null");
+ pw.println("Actual result = |" + result + "|");
+ } else {
+ passed = true;
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getPathTranslatedTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = true;
+ ServletContext sc = (ServletContext) request.getAttribute("servletContext");
+ String expectedResult = sc.getRealPath(request.getPathInfo());
+
+ String result = request.getPathTranslated();
+ // null will be returned if running out of a jar
+ if (expectedResult == null) {
+ if (result != null) {
+ passed = false;
+ pw.println("getPathTranslated() returned an incorrect result");
+ pw.println("Expected result = Null");
+ pw.println("Actual result = |" + result + "|");
+ }
+ } else if (!expectedResult.equals(result)) {
+ passed = false;
+ pw.println("getPathTranslated() returned an incorrect result");
+ pw.println("Expected result = " + expectedResult);
+ pw.println("Actual result = |" + result + "|");
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getQueryStringTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+
+ String expected = "qs=value1";
+ // we should get a not null value
+ String result = request.getQueryString();
+
+ if (result != null) {
+ if (!expected.equals(result)) {
+ passed = false;
+ pw.println("getQueryString() returned an incorrect result");
+ pw.println("Expected result = " + expected);
+ pw.println("Actual result = |" + result + "|");
+ } else {
+ passed = true;
+ }
+ } else {
+ passed = false;
+ pw.println("getQueryString() returned a null result");
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getQueryStringNullTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+ String result = request.getQueryString();
+
+ if (result != null) {
+ passed = false;
+ pw.println(
+ " HttpServletRequest.getQueryString() returned a Non-Null result");
+ pw.println(" Actual result = |" + result + "|");
+ } else {
+ passed = true;
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getRequestURITest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ boolean passed = false;
+
+ String expectedResult = request.getHeader("result") + "/TestServlet";
+ String result = request.getRequestURI();
+ // not null value expected
+ if (result != null) {
+ if (!result.equals(expectedResult)) {
+ passed = false;
+ pw.println("getRequestURI() returned an incorrect result");
+ pw.println("Expected result = " + expectedResult);
+ pw.println("Actual result = |" + result + "|");
+ } else {
+ passed = true;
+ }
+ } else {
+ passed = false;
+ pw.println("getRequestURI() returned a null result");
+ }
+
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getServletPathTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+ String expectedResult = "/TestServlet";
+ String result = request.getServletPath();
+
+ if (result != null) {
+ if (!result.equals(expectedResult)) {
+ passed = false;
+ pw.println("getServletPath() returned an incorrect result");
+ pw.println("Expected result = " + expectedResult);
+ pw.println("Actual result = |" + result + "|");
+ } else {
+ passed = true;
+ }
+ } else {
+ passed = false;
+ pw.println("getServletPath() returned a null result");
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getServletPathEmptyStringTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+ String expectedResult = "";
+ String result = request.getServletPath();
+
+ if (result != null) {
+ if (!result.equals(expectedResult)) {
+ passed = false;
+ pw.println("getServletPath() returned an incorrect result");
+ pw.println("Expected result = ''");
+ pw.println("Actual result = |" + result + "|");
+ } else {
+ passed = true;
+ }
+ } else {
+ passed = false;
+ pw.println("getServletPath() returned a null result");
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getSessionTest(PrintWriter pw, HttpServletRequest request,
+ HttpServletResponse response) throws ServletException, IOException {
+
+ boolean passed = false;
+ HttpSession sess = request.getSession();
+
+ if (sess == null) {
+ passed = false;
+ pw.println("getSession() returned a Null result");
+ } else {
+ passed = true;
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getSessionTrueSessionTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+ HttpSession expected = savedSession;
+ HttpSession actual = request.getSession(true);
+ if (actual != null) {
+ if (!actual.getId().equals(expected.getId())) {
+ passed = false;
+ pw.println("getSession(true) did not return the correct session id");
+ pw.println("expected=" + expected.getId());
+ pw.println("actual=" + actual.getId());
+ } else {
+ passed = true;
+ }
+ } else {
+ passed = false;
+ pw.println("getSession(true) returned a Null result");
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getSessionTrueNoSessionTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+
+ HttpSession sess = request.getSession(true);
+ if (sess != null) {
+ savedSession = sess;
+ savedSessionId = sess.getId();
+ passed = true;
+ } else {
+ passed = false;
+ pw.println("getSession(true) returned a Null result");
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getSessionFalseTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+ HttpSession sess = request.getSession(false);
+
+ if (sess != null) {
+ if (sess.isNew()) {
+ passed = true;
+ pw.println("getSession() did not returned a Null result");
+ pw.println("Actual=" + sess.toString());
+ } else {
+ passed = false;
+ pw.println("getSession() did not returned a Null result");
+ pw.println("Actual=" + sess.toString());
+ }
+ } else {
+ passed = true;
+ pw.println("getSession() returned a Null");
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void isRequestedSessionIdFromCookieTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ boolean result = request.isRequestedSessionIdFromCookie();
+
+ pw.println("Actual result = " + result);
+ }
+
+ public static void isRequestedSessionIdFromURLTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+ boolean expectedResult = false;
+ boolean result = request.isRequestedSessionIdFromURL();
+
+ if (result != expectedResult) {
+ passed = false;
+ pw.println("isRequestedSessionIdFromURL returned incorrect result");
+ pw.println("Expected result = " + expectedResult);
+ pw.println("Actual result = " + result);
+ } else {
+ passed = true;
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void isRequestedSessionIdValidTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+ boolean expectedResult = false;
+ boolean result = request.isRequestedSessionIdValid();
+
+ if (result != expectedResult) {
+ passed = false;
+ pw.println("isRequestedSessionIdValid() returned incorrect result");
+ pw.println("Expected result = " + expectedResult);
+ pw.println("Actual result = " + result);
+
+ } else {
+ passed = true;
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getRequestURLTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ boolean passed = false;
+ String expResult1 = null;
+ String expResult2 = null;
+ String result = request.getRequestURL().toString();
+
+ String scheme = request.getHeader("scheme");
+ String path = request.getHeader("servletPath").replace('-', '/');
+
+ expResult1 = scheme + "://";
+ expResult2 = path;
+
+ if (!result.startsWith(expResult1) && !result.endsWith(expResult2)) {
+ passed = false;
+ pw.println("Unexpected result returned from getRequestURL().");
+ pw.println("Expected " + expResult1 + "" + expResult2);
+ pw.println("Received: " + result);
+ } else {
+ passed = true;
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getRemoteUserTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ boolean passed = false;
+ String result = request.getRemoteUser();
+ if (result != null) {
+ passed = false;
+ pw.println("A non-null value was returned from getQueryString().");
+ pw.println("Received: " + result + "'");
+ } else {
+ passed = true;
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getRequestedSessionIdNullTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ boolean passed = false;
+ String result = request.getRequestedSessionId();
+ if (result != null) {
+ passed = false;
+ pw.println("A non-null value was returned from getRequestedSessionId()");
+ pw.println("Received: " + result);
+ } else {
+ passed = true;
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void invalidateSessionId(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ HttpSession sess = request.getSession();
+ savedRequestedSessionId = request.getRequestedSessionId();
+ sess.invalidate();
+ ServletTestUtil.printResult(pw, true);
+ }
+
+ public static void getRequestedSessionIdTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+
+ HttpSession sess = request.getSession(true);
+ if (sess != null) {
+ String actual = request.getRequestedSessionId();
+ if (actual != null) {
+ if (actual.equals(savedRequestedSessionId)) {
+ pw.println(
+ "getRequestedSessionId() returned correct requesteSessionId="
+ + savedRequestedSessionId);
+ passed = true;
+ } else {
+ passed = false;
+ pw.println(
+ "getRequestedSessionId() returned the incorrect request session id");
+ pw.println("Correct RequestedSessionId=" + savedRequestedSessionId);
+ pw.println("getRequestedSessionId =" + actual);
+ }
+ } else {
+ passed = false;
+ pw.println("getRequestedSessionId() returned a Null result");
+ }
+ } else {
+ passed = false;
+ pw.println("getSession(true) returned a Null result");
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getRequestedSessionIdTest1(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ boolean passed = false;
+
+ String actual = request.getRequestedSessionId();
+ String expected = request.getParameter("TCKidsetto");
+ if (actual != null) {
+ if (actual.equals(expected)) {
+ passed = true;
+ pw.println("Test returned with RequestdSessionId=" + actual);
+ } else {
+ pw.println(
+ "getRequestedSessionId() returned the incorrect request session id");
+ pw.println("Correct RequestedSessionId=" + expected);
+ pw.println("getRequestedSessionId =" + actual);
+ }
+ } else {
+ pw.println("getRequestedSessionId() returned a Null result");
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void getRequestedSessionIdTest2(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ boolean passed = false;
+
+ HttpSession sess = request.getSession(true);
+ if (sess != null) {
+ String actual = request.getRequestedSessionId();
+ String expected = request.getParameter("TCKidsetto");
+ if (actual != null) {
+ if (actual.equals(expected)) {
+ passed = true;
+ pw.println("Test returned with RequestdSessionId=" + actual);
+ } else {
+ pw.println(
+ "getRequestedSessionId() returned the incorrect request session id");
+ pw.println("Correct RequestedSessionId=" + expected);
+ pw.println("getRequestedSessionId =" + actual);
+ }
+ } else {
+ pw.println("getRequestedSessionId() returned a Null result");
+ }
+ } else {
+ passed = false;
+ pw.println("getSession(true) returned a Null result");
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void sessionTimeoutTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+
+ boolean passed = false;
+
+ HttpSession sess = request.getSession();
+ if (sess != null) {
+ sess.setMaxInactiveInterval(60);
+
+ try {
+ Thread.sleep(90000);
+ } catch (java.lang.InterruptedException ex) {
+ pw.println("Sleep interupted - " + ex.getMessage());
+ }
+
+ if (request.getSession(false) != null) {
+ passed = true;
+ pw.println("Session is still alive after timeout - 90 seconds");
+ } else {
+ passed = false;
+ pw.println("Session is expired after timeout - 90 seconds");
+ }
+ } else {
+ passed = false;
+ pw.println("getSession() returned a Null result");
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void changeSessionIDTest(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ Boolean passed = true;
+
+ try {
+ request.changeSessionId();
+ passed = false;
+ pw.println("Test Failed. ");
+ pw.println("Expected ServletException not thrown");
+ } catch (IllegalStateException lex) {
+ pw.println("Test Passed.");
+ pw.println("Expected IllegalStateException thrown: " + lex.getMessage());
+ } catch (Exception oex) {
+ passed = false;
+ pw.println("Test Failed.");
+ pw.print("Unexpected Exception thrown: " + oex.getMessage());
+ }
+ ServletTestUtil.printResult(pw, passed);
+ }
+
+ public static void changeSessionIDTest1(PrintWriter pw,
+ HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ Boolean pass = true;
+ String attrName_OLD = "OLD";
+ String attrName_NEW = "NEW";
+
+ HttpSession session = request.getSession(true);
+ String sessionId_old = session.getId();
+ String sessionId_new = request.changeSessionId();
+
+ if (sessionId_new.equals(sessionId_old)) {
+ pass = false;
+ pw.append(
+ "HttpServletRequest.changeSessionId didn't return new Session ID,"
+ + "it returns the original sesison ID " + sessionId_old);
+ }
+
+ if (!((String) request.getSession(false).getAttribute(attrName_OLD))
+ .equals(sessionId_old)) {
+ pass = false;
+ pw.append(
+ "Original Session ID does not sync up. Before ChangeSessionId is called: "
+ + sessionId_old + " From TCKHttpSessionIDListener "
+ + request.getSession(false).getAttribute(attrName_OLD));
+ }
+
+ if (((String) request.getSession(false).getAttribute(attrName_NEW))
+ .equals(sessionId_old)) {
+ pass = false;
+ pw.append("Session ID didn't change: " + sessionId_old);
+ }
+
+ if (!((String) request.getSession(false).getAttribute(attrName_NEW))
+ .equals(sessionId_new)) {
+ pass = false;
+ pw.append("New Session ID does not sync up. ChangeSessionId returned "
+ + sessionId_new + " TCKHttpSessionIDListener returned "
+ + request.getSession(false).getAttribute(attrName_NEW));
+ }
+
+ pw.append("Original before changeSessionId is called =" + sessionId_old
+ + "=changeSessionId returned=" + sessionId_new
+ + "=oroginal from TCKHttpSessionIDListener="
+ + request.getSession(false).getAttribute(attrName_OLD)
+ + "=new from TCKHttpSessionIDListener="
+ + request.getSession(false).getAttribute(attrName_NEW));
+ ServletTestUtil.printResult(pw, pass);
+ }
+ // --------------- END jakarta_servlet_http.HttpServletRequest
+ // -------------------
+}
diff --git a/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/servlets/build.xml b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/servlets/build.xml
new file mode 100644
index 0000000000..88ad0b1210
--- /dev/null
+++ b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/servlets/build.xml
@@ -0,0 +1,23 @@
+
+
+
+
+
diff --git a/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/util/Data.java b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/util/Data.java
new file mode 100644
index 0000000000..d3f4625b61
--- /dev/null
+++ b/tck/tck-runtime/src/main/java/com/sun/ts/tests/servlet/common/util/Data.java
@@ -0,0 +1,65 @@
+/*
+*
+* The Apache Software License, Version 1.1
+*
+* Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1999-2001 The Apache Software Foundation. All rights
+* reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions
+* are met:
+*
+* 1. Redistributions of source code must retain the above copyright
+* notice, this list of conditions and the following disclaimer.
+*
+* 2. Redistributions in binary form must reproduce the above copyright
+* notice, this list of conditions and the following disclaimer in
+* the documentation and/or other materials provided with the
+* distribution.
+*
+* 3. The end-user documentation included with the redistribution, if
+* any, must include the following acknowlegement:
+* "This product includes software developed by the
+* Apache Software Foundation (http://www.apache.org/)."
+* Alternately, this acknowlegement may appear in the software itself,
+* if and wherever such third-party acknowlegements normally appear.
+*
+* 4. The names "The Jakarta Project", "Tomcat", and "Apache Software
+* Foundation" must not be used to endorse or promote products derived
+* from this software without prior written permission. For written
+* permission, please contact apache@apache.org.
+*
+* 5. Products derived from this software may not be called "Apache"
+* nor may "Apache" appear in their names without prior written
+* permission of the Apache Group.
+*
+* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
+* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
+* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+* SUCH DAMAGE.
+* ====================================================================
+*
+* This software consists of voluntary contributions made by many
+* individuals on behalf of the Apache Software Foundation. For more
+* information on the Apache Software Foundation, please see
+*