You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@tomcat.apache.org by kk...@apache.org on 2016/01/21 22:55:19 UTC
svn commit: r1726112 [2/2] - in
/tomcat/tc6.0.x/branches/tomcat6-testing_20160106: BRANCH-README.txt
BRANCH-diff.diff
Added: tomcat/tc6.0.x/branches/tomcat6-testing_20160106/BRANCH-diff.diff
URL: http://svn.apache.org/viewvc/tomcat/tc6.0.x/branches/tomcat6-testing_20160106/BRANCH-diff.diff?rev=1726112&view=auto
==============================================================================
--- tomcat/tc6.0.x/branches/tomcat6-testing_20160106/BRANCH-diff.diff (added)
+++ tomcat/tc6.0.x/branches/tomcat6-testing_20160106/BRANCH-diff.diff Thu Jan 21 21:55:19 2016
@@ -0,0 +1,3922 @@
+Index: test/build.xml
+===================================================================
+--- test/build.xml (.../trunk) (revision 1726111)
++++ test/build.xml (.../branches/tomcat6-testing_20160106) (revision 1726111)
+@@ -1,71 +0,0 @@
+-<?xml version="1.0"?>
+-<!--
+- Licensed to the Apache Software Foundation (ASF) under one or more
+- contributor license agreements. See the NOTICE file distributed with
+- this work for additional information regarding copyright ownership.
+- The ASF licenses this file to You under the Apache License, Version 2.0
+- (the "License"); you may not use this file except in compliance with
+- the License. You may obtain a copy of the License at
+-
+- http://www.apache.org/licenses/LICENSE-2.0
+-
+- Unless required by applicable law or agreed to in writing, software
+- distributed under the License is distributed on an "AS IS" BASIS,
+- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+- See the License for the specific language governing permissions and
+- limitations under the License.
+--->
+-<project name="Tomcat 6.0" default="all" basedir=".">
+-
+- <!-- See "build.properties.sample" in the top level directory for all -->
+- <!-- property values you must customize for successful building!!! -->
+- <property file="${user.home}/build.properties"/>
+- <property file="build.properties"/>
+-
+- <property file="build.properties.default"/>
+-
+- <property name="test.classes" value="${basedir}/output/classes"/>
+- <property name="tomcat.build" value="${basedir}/../output/build"/>
+-
+- <property name="compile.source" value="1.5"/>
+- <property name="compile.debug" value="true"/>
+-
+- <property name="junit.jar" value="${junit.home}/junit.jar"/>
+- <property name="test.runner" value="junit.textui.TestRunner"/>
+-
+- <path id="tomcat.test.classpath">
+- <pathelement location="${test.classes}"/>
+- <pathelement location="${junit.jar}"/>
+- <fileset dir="${tomcat.build}/lib/">
+- <include name="tomcat-coyote.jar"/>
+- </fileset>
+- <fileset dir="${tomcat.build}/bin/">
+- <include name="tomcat-juli.jar"/>
+- </fileset>
+- </path>
+-
+- <target name="compile">
+-
+- <mkdir dir="${test.classes}"/>
+-
+- <!-- Compile -->
+- <javac srcdir="." destdir="${test.classes}"
+- debug="${compile.debug}"
+- deprecation="${compile.deprecation}"
+- source="${compile.source}"
+- optimize="${compile.optimize}"
+- encoding="ISO-8859-1">
+- <classpath refid="tomcat.test.classpath" />
+- <include name="org/apache/tomcat/util/**" />
+- </javac>
+-
+- </target>
+-
+- <target name="all" depends="compile">
+- <java dir="${test.classes}" classname="${test.runner}" fork="yes" failonerror="${test.failonerror}">
+- <arg value="org.apache.tomcat.util.http.TestCookies"/>
+- <classpath refid="tomcat.test.classpath"/>
+- </java>
+-
+- </target>
+-</project>
+Index: test/deployment/dirNoContext/index.html
+===================================================================
+--- test/deployment/dirNoContext/index.html (.../trunk) (revision 0)
++++ test/deployment/dirNoContext/index.html (.../branches/tomcat6-testing_20160106) (revision 1726111)
+@@ -0,0 +1,22 @@
++<!--
++ Licensed to the Apache Software Foundation (ASF) under one or more
++ contributor license agreements. See the NOTICE file distributed with
++ this work for additional information regarding copyright ownership.
++ The ASF licenses this file to You under the Apache License, Version 2.0
++ (the "License"); you may not use this file except in compliance with
++ the License. You may obtain a copy of the License at
++
++ http://www.apache.org/licenses/LICENSE-2.0
++
++ Unless required by applicable law or agreed to in writing, software
++ distributed under the License is distributed on an "AS IS" BASIS,
++ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ See the License for the specific language governing permissions and
++ limitations under the License.
++-->
++<!-- dirNoContext -->
++<html>
++ <body>
++ <p>Directory based web application with no context.xml file.</p>
++ </body>
++</html>
+\ No newline at end of file
+
+Property changes on: test/deployment/dirNoContext/index.html
+___________________________________________________________________
+Added: svn:eol-style
+## -0,0 +1 ##
++native
+\ No newline at end of property
+Index: test/deployment/dirContext/index.html
+===================================================================
+--- test/deployment/dirContext/index.html (.../trunk) (revision 0)
++++ test/deployment/dirContext/index.html (.../branches/tomcat6-testing_20160106) (revision 1726111)
+@@ -0,0 +1,22 @@
++<!--
++ Licensed to the Apache Software Foundation (ASF) under one or more
++ contributor license agreements. See the NOTICE file distributed with
++ this work for additional information regarding copyright ownership.
++ The ASF licenses this file to You under the Apache License, Version 2.0
++ (the "License"); you may not use this file except in compliance with
++ the License. You may obtain a copy of the License at
++
++ http://www.apache.org/licenses/LICENSE-2.0
++
++ Unless required by applicable law or agreed to in writing, software
++ distributed under the License is distributed on an "AS IS" BASIS,
++ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ See the License for the specific language governing permissions and
++ limitations under the License.
++-->
++<!-- dirContext -->
++<html>
++ <body>
++ <p>Directory based web application with a context.xml file.</p>
++ </body>
++</html>
+\ No newline at end of file
+
+Property changes on: test/deployment/dirContext/index.html
+___________________________________________________________________
+Added: svn:eol-style
+## -0,0 +1 ##
++native
+\ No newline at end of property
+Index: test/deployment/dirContext/META-INF/context.xml
+===================================================================
+--- test/deployment/dirContext/META-INF/context.xml (.../trunk) (revision 0)
++++ test/deployment/dirContext/META-INF/context.xml (.../branches/tomcat6-testing_20160106) (revision 1726111)
+@@ -0,0 +1,17 @@
++<!--
++ Licensed to the Apache Software Foundation (ASF) under one or more
++ contributor license agreements. See the NOTICE file distributed with
++ this work for additional information regarding copyright ownership.
++ The ASF licenses this file to You under the Apache License, Version 2.0
++ (the "License"); you may not use this file except in compliance with
++ the License. You may obtain a copy of the License at
++
++ http://www.apache.org/licenses/LICENSE-2.0
++
++ Unless required by applicable law or agreed to in writing, software
++ distributed under the License is distributed on an "AS IS" BASIS,
++ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ See the License for the specific language governing permissions and
++ limitations under the License.
++-->
++<Context sessionCookieName="DIR_CONTEXT" />
+\ No newline at end of file
+
+Property changes on: test/deployment/dirContext/META-INF/context.xml
+___________________________________________________________________
+Added: svn:eol-style
+## -0,0 +1 ##
++native
+\ No newline at end of property
+Index: test/org/apache/catalina/connector/TestConnector.java
+===================================================================
+--- test/org/apache/catalina/connector/TestConnector.java (.../trunk) (revision 0)
++++ test/org/apache/catalina/connector/TestConnector.java (.../branches/tomcat6-testing_20160106) (revision 1726111)
+@@ -0,0 +1,44 @@
++/*
++ * Licensed to the Apache Software Foundation (ASF) under one or more
++ * contributor license agreements. See the NOTICE file distributed with
++ * this work for additional information regarding copyright ownership.
++ * The ASF licenses this file to You under the Apache License, Version 2.0
++ * (the "License"); you may not use this file except in compliance with
++ * the License. You may obtain a copy of the License at
++ *
++ * http://www.apache.org/licenses/LICENSE-2.0
++ *
++ * Unless required by applicable law or agreed to in writing, software
++ * distributed under the License is distributed on an "AS IS" BASIS,
++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ * See the License for the specific language governing permissions and
++ * limitations under the License.
++ */
++package org.apache.catalina.connector;
++
++import org.junit.Test;
++
++import static org.junit.Assert.assertTrue;
++
++import org.apache.catalina.startup.Tomcat;
++import org.apache.catalina.startup.TomcatBaseTest;
++
++/**
++ * Test cases for {@link Connector}.
++ */
++public class TestConnector extends TomcatBaseTest {
++
++ @Test
++ public void testPort() throws Exception {
++ Tomcat tomcat = getTomcatInstance();
++
++ Connector connector1 = tomcat.getConnector();
++ connector1.setPort(0);
++
++ tomcat.start();
++
++ int localPort1 = connector1.getLocalPort();
++
++ assertTrue(localPort1 > 0);
++ }
++}
+
+Property changes on: test/org/apache/catalina/connector/TestConnector.java
+___________________________________________________________________
+Added: svn:eol-style
+## -0,0 +1 ##
++native
+\ No newline at end of property
+Index: test/org/apache/catalina/startup/TestTomcat.java
+===================================================================
+--- test/org/apache/catalina/startup/TestTomcat.java (.../trunk) (revision 0)
++++ test/org/apache/catalina/startup/TestTomcat.java (.../branches/tomcat6-testing_20160106) (revision 1726111)
+@@ -0,0 +1,594 @@
++/*
++ * Licensed to the Apache Software Foundation (ASF) under one or more
++ * contributor license agreements. See the NOTICE file distributed with
++ * this work for additional information regarding copyright ownership.
++ * The ASF licenses this file to You under the Apache License, Version 2.0
++ * (the "License"); you may not use this file except in compliance with
++ * the License. You may obtain a copy of the License at
++ *
++ * http://www.apache.org/licenses/LICENSE-2.0
++ *
++ * Unless required by applicable law or agreed to in writing, software
++ * distributed under the License is distributed on an "AS IS" BASIS,
++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ * See the License for the specific language governing permissions and
++ * limitations under the License.
++ */
++package org.apache.catalina.startup;
++
++import java.io.File;
++import java.io.IOException;
++import java.io.InputStream;
++import java.io.InputStreamReader;
++import java.io.Reader;
++import java.net.URL;
++import java.net.URLConnection;
++import java.util.concurrent.atomic.AtomicInteger;
++
++import javax.naming.InitialContext;
++import javax.naming.NamingException;
++import javax.servlet.ServletException;
++import javax.servlet.http.HttpServlet;
++import javax.servlet.http.HttpServletRequest;
++import javax.servlet.http.HttpServletResponse;
++import javax.servlet.http.HttpSession;
++
++import static org.junit.Assert.assertEquals;
++import static org.junit.Assert.assertNotNull;
++import static org.junit.Assert.assertNull;
++import static org.junit.Assert.assertTrue;
++import static org.junit.Assert.fail;
++
++import org.junit.Test;
++
++import org.apache.catalina.Context;
++import org.apache.catalina.Host;
++import org.apache.catalina.core.StandardContext;
++import org.apache.catalina.core.StandardHost;
++import org.apache.catalina.deploy.ContextEnvironment;
++import org.apache.catalina.deploy.ContextResourceLink;
++import org.apache.catalina.ha.context.ReplicatedContext;
++import org.apache.tomcat.util.buf.ByteChunk;
++
++public class TestTomcat extends TomcatBaseTest {
++
++ /**
++ * Simple servlet to test in-line registration.
++ */
++ public static class HelloWorld extends HttpServlet {
++
++ private static final long serialVersionUID = 1L;
++
++ @Override
++ public void doGet(HttpServletRequest req, HttpServletResponse res)
++ throws IOException {
++ res.getWriter().write("Hello world");
++ }
++ }
++
++ /**
++ * Simple servlet to test the default session manager.
++ */
++ public static class HelloWorldSession extends HttpServlet {
++
++ private static final long serialVersionUID = 1L;
++
++ @Override
++ public void doGet(HttpServletRequest req, HttpServletResponse res)
++ throws IOException {
++ HttpSession s = req.getSession(true);
++ s.getId();
++ res.getWriter().write("Hello world");
++ }
++ }
++
++ /**
++ * Simple servlet to test JNDI
++ */
++ public static class HelloWorldJndi extends HttpServlet {
++
++ private static final long serialVersionUID = 1L;
++
++ private static final String JNDI_ENV_NAME = "test";
++
++ @Override
++ public void doGet(HttpServletRequest req, HttpServletResponse res)
++ throws IOException {
++
++ String name = null;
++
++ try {
++ javax.naming.Context initCtx = new InitialContext();
++ javax.naming.Context envCtx =
++ (javax.naming.Context) initCtx.lookup("java:comp/env");
++ name = (String) envCtx.lookup(JNDI_ENV_NAME);
++ } catch (NamingException e) {
++ IOException ioe = new IOException(e.getMessage());
++ ioe.initCause(e);
++ throw ioe;
++ }
++
++ res.getWriter().write("Hello, " + name);
++ }
++ }
++
++ /**
++ * Servlet that tries to obtain a URL for WEB-INF/web.xml
++ */
++ public static class GetResource extends HttpServlet {
++
++ private static final long serialVersionUID = 1L;
++
++ @Override
++ public void doGet(HttpServletRequest req, HttpServletResponse res)
++ throws IOException {
++ URL url = getServletContext().getResource("/WEB-INF/web.xml");
++
++ res.getWriter().write("The URL obtained for /WEB-INF/web.xml was ");
++ if (url == null) {
++ res.getWriter().write("null");
++ } else {
++ res.getWriter().write(url.toString() + "\n");
++ res.getWriter().write("The first 20 characters of that resource are:\n");
++
++ // Read some content from the resource
++ URLConnection conn = url.openConnection();
++
++ InputStream is = null;
++ Reader reader = null;
++ char cbuf[] = new char[20];
++ int read = 0;
++ try {
++ is = conn.getInputStream();
++ reader = new InputStreamReader(is);
++ while (read < 20) {
++ int len = reader.read(cbuf, read, cbuf.length - read);
++ res.getWriter().write(cbuf, read, len);
++ read = read + len;
++ }
++ } finally {
++ if (reader != null) {
++ try { reader.close(); } catch(IOException ioe) {/*Ignore*/}
++ }
++ if (is != null) {
++ try { is.close(); } catch(IOException ioe) {/*Ignore*/}
++ }
++ }
++
++
++ }
++
++
++ }
++ }
++
++ /**
++ * Simple servlet to test initialization of servlet instances.
++ */
++ private static class InitCount extends HttpServlet {
++
++ private static final long serialVersionUID = 1L;
++
++ private AtomicInteger callCount = new AtomicInteger(0);
++
++ @Override
++ public void init() throws ServletException {
++ super.init();
++ callCount.incrementAndGet();
++ }
++
++ @Override
++ protected void doGet(HttpServletRequest req, HttpServletResponse resp)
++ throws ServletException, IOException {
++ resp.setContentType("text/plain");
++ resp.getWriter().print("OK");
++ }
++
++ public int getCallCount() {
++ return callCount.intValue();
++ }
++ }
++
++
++// /**
++// * Simple Realm that uses a configurable {@link Map} to link user names and
++// * passwords.
++// */
++// public static final class MapRealm extends RealmBase {
++// private Map<String,String> users = new HashMap<String,String>();
++// private Map<String,List<String>> roles =
++// new HashMap<String,List<String>>();
++//
++// public void addUser(String username, String password) {
++// users.put(username, password);
++// }
++//
++// public void addUserRole(String username, String role) {
++// List<String> userRoles = roles.get(username);
++// if (userRoles == null) {
++// userRoles = new ArrayList<String>();
++// roles.put(username, userRoles);
++// }
++// userRoles.add(role);
++// }
++//
++// @Override
++// protected String getName() {
++// return "MapRealm";
++// }
++//
++// @Override
++// protected String getPassword(String username) {
++// return users.get(username);
++// }
++//
++// @Override
++// protected Principal getPrincipal(String username) {
++// return new GenericPrincipal(username, getPassword(username),
++// roles.get(username));
++// }
++//
++// }
++
++ /**
++ * Start tomcat with a single context and one
++ * servlet - all programmatic, no server.xml or
++ * web.xml used.
++ *
++ * @throws Exception
++ */
++ @Test
++ public void testProgrammatic() throws Exception {
++ Tomcat tomcat = getTomcatInstance();
++
++ // No file system docBase required
++ Context ctx = tomcat.addContext("", null);
++
++ // You can customize the context by calling
++ // its API
++
++ Tomcat.addServlet(ctx, "myServlet", new HelloWorld());
++ ctx.addServletMapping("/", "myServlet");
++
++ tomcat.start();
++
++ ByteChunk res = getUrl("http://localhost:" + getPort() + "/");
++ assertEquals("Hello world", res.toString());
++ }
++
++ @Test
++ public void testSingleWebapp() throws Exception {
++ Tomcat tomcat = getTomcatInstance();
++
++ File appDir = new File(getBuildDirectory(), "webapps/examples");
++
++ tomcat.addWebapp(null, "/examples", appDir.getAbsolutePath());
++
++ tomcat.start();
++
++ ByteChunk res = getUrl("http://localhost:" + getPort() +
++ "/examples/servlets/servlet/HelloWorldExample");
++ String text = res.toString();
++ assertTrue(text, text.indexOf("<h1>Hello World!</h1>") > 0);
++ }
++
++ @Test
++ public void testJsps() throws Exception {
++ Tomcat tomcat = getTomcatInstance();
++
++ File appDir = new File(getBuildDirectory(), "webapps/examples");
++ // app dir is relative to server home
++ tomcat.addWebapp(null, "/examples", appDir.getAbsolutePath());
++
++ tomcat.start();
++
++ ByteChunk res = getUrl("http://localhost:" + getPort() +
++ "/examples/jsp/jsp2/el/basic-arithmetic.jsp");
++ String text = res.toString();
++ assertTrue(text, text.indexOf("<td>${(1==2) ? 3 : 4}</td>") > 0);
++ }
++
++ @Test
++ public void testSession() throws Exception {
++ Tomcat tomcat = getTomcatInstance();
++
++ // No file system docBase required
++ Context ctx = tomcat.addContext("", null);
++ // You can customize the context by calling
++ // its API
++
++ Tomcat.addServlet(ctx, "myServlet", new HelloWorldSession());
++ ctx.addServletMapping("/", "myServlet");
++
++ tomcat.start();
++
++ ByteChunk res = getUrl("http://localhost:" + getPort() + "/");
++ assertEquals("Hello world", res.toString());
++ }
++
++ @Test
++ public void testLaunchTime() throws Exception {
++ Tomcat tomcat = getTomcatInstance();
++ long t0 = System.currentTimeMillis();
++ tomcat.addContext(null, "", ".");
++ tomcat.start();
++ log.info("Tomcat started in [" + (System.currentTimeMillis() - t0)
++ + "] ms");
++ }
++
++
++ /**
++ * Test for enabling JNDI.
++ */
++ @Test
++ public void testEnableNaming() throws Exception {
++ Tomcat tomcat = getTomcatInstance();
++
++ // No file system docBase required
++ Context ctx = tomcat.addContext("", null);
++
++ // You can customise the context by calling its API
++
++ // Enable JNDI - it is disabled by default
++ tomcat.enableNaming();
++
++ ContextEnvironment environment = new ContextEnvironment();
++ environment.setType("java.lang.String");
++ environment.setName(HelloWorldJndi.JNDI_ENV_NAME);
++ environment.setValue("Tomcat User");
++ ctx.getNamingResources().addEnvironment(environment);
++
++ Tomcat.addServlet(ctx, "jndiServlet", new HelloWorldJndi());
++ ctx.addServletMapping("/", "jndiServlet");
++
++ tomcat.start();
++
++ ByteChunk res = getUrl("http://localhost:" + getPort() + "/");
++ assertEquals("Hello, Tomcat User", res.toString());
++ }
++
++ /**
++ * Test for enabling JNDI and using global resources.
++ */
++ @Test
++ public void testEnableNamingGlobal() throws Exception {
++ Tomcat tomcat = getTomcatInstance();
++
++ // No file system docBase required
++ Context ctx = tomcat.addContext("", null);
++
++ // You can customise the context by calling its API
++
++ // Enable JNDI - it is disabled by default
++ tomcat.enableNaming();
++
++ ContextEnvironment environment = new ContextEnvironment();
++ environment.setType("java.lang.String");
++ environment.setName("globalTest");
++ environment.setValue("Tomcat User");
++ tomcat.getServer().getGlobalNamingResources().addEnvironment(environment);
++
++ ContextResourceLink link = new ContextResourceLink();
++ link.setGlobal("globalTest");
++ link.setName(HelloWorldJndi.JNDI_ENV_NAME);
++ ctx.getNamingResources().addResourceLink(link);
++
++ Tomcat.addServlet(ctx, "jndiServlet", new HelloWorldJndi());
++ ctx.addServletMapping("/", "jndiServlet");
++
++ tomcat.start();
++
++ ByteChunk res = getUrl("http://localhost:" + getPort() + "/");
++ assertEquals("Hello, Tomcat User", res.toString());
++ }
++
++
++ /**
++ * Test for https://bz.apache.org/bugzilla/show_bug.cgi?id=47866
++ */
++ @Test
++ public void testGetResource() throws Exception {
++ Tomcat tomcat = getTomcatInstance();
++
++ String contextPath = "/examples";
++
++ File appDir = new File(getBuildDirectory(), "webapps" + contextPath);
++ // app dir is relative to server home
++ Context ctx =
++ tomcat.addWebapp(null, "/examples", appDir.getAbsolutePath());
++
++ Tomcat.addServlet(ctx, "testGetResource", new GetResource());
++ ctx.addServletMapping("/testGetResource", "testGetResource");
++
++ tomcat.start();
++
++ ByteChunk res = new ByteChunk();
++
++ int rc =getUrl("http://localhost:" + getPort() + contextPath +
++ "/testGetResource", res, null);
++ assertEquals(HttpServletResponse.SC_OK, rc);
++ assertTrue(res.toString().contains("<?xml version=\"1.0\" "));
++ }
++
++ @Test
++ public void testBug50826() throws Exception {
++ Tomcat tomcat = getTomcatInstance();
++ String contextPath = "/examples";
++
++ File appDir = new File(getBuildDirectory(), "webapps" + contextPath);
++ // app dir is relative to server home
++ tomcat.addWebapp(null, "/examples", appDir.getAbsolutePath());
++
++ Exception e = null;
++ try {
++ tomcat.destroy();
++ } catch (Exception ex) {
++ ex.printStackTrace();
++ e = ex;
++ }
++ assertNull(e);
++ }
++
++ @Test
++ public void testBug53301() throws Exception {
++ Tomcat tomcat = getTomcatInstance();
++
++ // No file system docBase required
++ Context ctx = tomcat.addContext("", null);
++
++ InitCount initCount = new InitCount();
++ Tomcat.addServlet(ctx, "initCount", initCount);
++ ctx.addServletMapping("/", "initCount");
++
++ tomcat.start();
++
++ ByteChunk res = getUrl("http://localhost:" + getPort() + "/");
++ assertEquals("OK", res.toString());
++
++ assertEquals(1, initCount.getCallCount());
++ }
++
++ @Test
++ public void testGetWebappConfigFileFromDirectory() {
++ Tomcat tomcat = new Tomcat();
++ assertNotNull(tomcat.getWebappConfigFile("test/deployment/dirContext", ""));
++ }
++
++ @Test
++ public void testGetWebappConfigFileFromDirectoryNegative() {
++ Tomcat tomcat = new Tomcat();
++ assertNull(tomcat.getWebappConfigFile("test/deployment/dirNoContext", ""));
++ }
++
++// Reading context.xml from a war file without copying it
++// is not implemented in Tomcat 6. (BZ 48662, r928380)
++// @Test
++// public void testGetWebappConfigFileFromJar() {
++// Tomcat tomcat = new Tomcat();
++// assertNotNull(tomcat.getWebappConfigFile("test/deployment/context.war", ""));
++// }
++//
++// @Test
++// public void testGetWebappConfigFileFromJarNegative() {
++// Tomcat tomcat = new Tomcat();
++// assertNull(tomcat.getWebappConfigFile("test/deployment/noContext.war", ""));
++// }
++//
++// @Test
++// public void testBug51526() throws Exception {
++// Tomcat tomcat = getTomcatInstance();
++//
++// File appFile = new File("test/deployment/context.war");
++// StandardContext context = (StandardContext) tomcat.addWebapp(null, "/test",
++// appFile.getAbsolutePath());
++//
++// tomcat.start();
++//
++// assertEquals("WAR_CONTEXT", context.getSessionCookieName());
++// }
++//
++// @Test
++// public void testGetDefaultContextPerAddWebapp() {
++// Tomcat tomcat = getTomcatInstance();
++//
++// File appFile = new File("test/deployment/context.war");
++// Context context = tomcat.addWebapp(null,
++// "/test", appFile.getAbsolutePath());
++//
++// assertEquals(StandardContext.class.getName(), context.getClass()
++// .getName());
++// }
++//
++// @Test
++// public void testGetBrokenContextPerAddWepapp() {
++// Tomcat tomcat = getTomcatInstance();
++// Host host = tomcat.getHost();
++// if (host instanceof StandardHost) {
++// ((StandardHost) host).setContextClass("InvalidContextClassName");
++// }
++//
++// try {
++// File appFile = new File("test/deployment/context.war");
++// tomcat.addWebapp(null, "/test", appFile.getAbsolutePath());
++// fail();
++// } catch (IllegalArgumentException e) {
++// // OK
++// }
++// }
++//
++// @Test
++// public void testGetCustomContextPerAddWebappWithNullHost() {
++// Tomcat tomcat = getTomcatInstance();
++// Host host = tomcat.getHost();
++// if (host instanceof StandardHost) {
++// ((StandardHost) host).setContextClass(ReplicatedContext.class
++// .getName());
++// }
++//
++// File appFile = new File("test/deployment/context.war");
++// Context context = tomcat.addWebapp(null, "/test",
++// appFile.getAbsolutePath());
++//
++// assertEquals(ReplicatedContext.class.getName(), context.getClass()
++// .getName());
++// }
++//
++// @Test
++// public void testGetCustomContextPerAddWebappWithHost() {
++// Tomcat tomcat = getTomcatInstance();
++// Host host = tomcat.getHost();
++// if (host instanceof StandardHost) {
++// ((StandardHost) host).setContextClass(ReplicatedContext.class
++// .getName());
++// }
++//
++// File appFile = new File("test/deployment/context.war");
++// Context context = tomcat.addWebapp(host, "/test",
++// appFile.getAbsolutePath());
++//
++// assertEquals(ReplicatedContext.class.getName(), context.getClass()
++// .getName());
++// }
++
++ @Test
++ public void testGetDefaultContextPerAddContext() {
++ Tomcat tomcat = getTomcatInstance();
++
++ // No file system docBase required
++ Context ctx = tomcat.addContext(null, "", null);
++ assertEquals(StandardContext.class.getName(), ctx.getClass().getName());
++ }
++
++ @Test
++ public void testGetBrokenContextPerAddContext() {
++ Tomcat tomcat = getTomcatInstance();
++ Host host = tomcat.getHost();
++ if (host instanceof StandardHost) {
++ ((StandardHost) host).setContextClass("InvalidContextClassName");
++ }
++
++ // No file system docBase required
++ try {
++ tomcat.addContext(null, "", null);
++ fail();
++ } catch (IllegalArgumentException e) {
++ // OK
++ }
++ }
++
++ @Test
++ public void testGetCustomContextPerAddContextWithHost() {
++ Tomcat tomcat = getTomcatInstance();
++ Host host = tomcat.getHost();
++ if (host instanceof StandardHost) {
++ ((StandardHost) host).setContextClass(ReplicatedContext.class
++ .getName());
++ }
++
++ // No file system docBase required
++ Context ctx = tomcat.addContext(host, "", null);
++ assertEquals(ReplicatedContext.class.getName(), ctx.getClass()
++ .getName());
++ }
++
++}
+
+Property changes on: test/org/apache/catalina/startup/TestTomcat.java
+___________________________________________________________________
+Added: svn:eol-style
+## -0,0 +1 ##
++native
+\ No newline at end of property
+Index: test/org/apache/catalina/startup/Tomcat.java
+===================================================================
+--- test/org/apache/catalina/startup/Tomcat.java (.../trunk) (revision 0)
++++ test/org/apache/catalina/startup/Tomcat.java (.../branches/tomcat6-testing_20160106) (revision 1726111)
+@@ -0,0 +1,1207 @@
++/*
++ * Licensed to the Apache Software Foundation (ASF) under one or more
++ * contributor license agreements. See the NOTICE file distributed with
++ * this work for additional information regarding copyright ownership.
++ * The ASF licenses this file to You under the Apache License, Version 2.0
++ * (the "License"); you may not use this file except in compliance with
++ * the License. You may obtain a copy of the License at
++ *
++ * http://www.apache.org/licenses/LICENSE-2.0
++ *
++ * Unless required by applicable law or agreed to in writing, software
++ * distributed under the License is distributed on an "AS IS" BASIS,
++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ * See the License for the specific language governing permissions and
++ * limitations under the License.
++ */
++package org.apache.catalina.startup;
++
++import java.io.File;
++import java.io.IOException;
++import java.lang.reflect.InvocationTargetException;
++import java.util.Stack;
++
++import javax.servlet.Servlet;
++import javax.servlet.ServletException;
++
++import org.apache.catalina.Container;
++import org.apache.catalina.Context;
++import org.apache.catalina.Engine;
++import org.apache.catalina.Globals;
++import org.apache.catalina.Host;
++import org.apache.catalina.Lifecycle;
++import org.apache.catalina.LifecycleEvent;
++import org.apache.catalina.LifecycleException;
++import org.apache.catalina.LifecycleListener;
++import org.apache.catalina.Server;
++import org.apache.catalina.Service;
++import org.apache.catalina.Wrapper;
++import org.apache.catalina.connector.Connector;
++import org.apache.catalina.core.NamingContextListener;
++import org.apache.catalina.core.StandardContext;
++import org.apache.catalina.core.StandardEngine;
++import org.apache.catalina.core.StandardHost;
++import org.apache.catalina.core.StandardServer;
++import org.apache.catalina.core.StandardService;
++import org.apache.catalina.core.StandardWrapper;
++
++// TODO: lazy init for the temp dir - only when a JSP is compiled or
++// get temp dir is called we need to create it. This will avoid the
++// need for the baseDir
++
++// TODO: allow contexts without a base dir - i.e.
++// only programmatic. This would disable the default servlet.
++
++/**
++ * Minimal tomcat starter for embedding/unit tests.
++ *
++ * Tomcat supports multiple styles of configuration and
++ * startup - the most common and stable is server.xml-based,
++ * implemented in org.apache.catalina.startup.Bootstrap.
++ *
++ * This class is for use in apps that embed tomcat.
++ * Requirements:
++ *
++ * - all tomcat classes and possibly servlets are in the classpath.
++ * ( for example all is in one big jar, or in eclipse CP, or in any other
++ * combination )
++ *
++ * - we need one temporary directory for work files
++ *
++ * - no config file is required. This class provides methods to
++ * use if you have a webapp with a web.xml file, but it is
++ * optional - you can use your own servlets.
++ *
++ * There are a variety of 'add' methods to configure servlets and webapps. These
++ * methods, by default, create a simple in-memory security realm and apply it.
++ * If you need more complex security processing, you can define a subclass of
++ * this class.
++ *
++ * This class provides a set of convenience methods for configuring webapp
++ * contexts, all overloads of the method <pre>addWebapp</pre>. These methods
++ * create a webapp context, configure it, and then add it to a {@link Host}.
++ * They do not use a global default web.xml; rather, they add a lifecycle
++ * listener that adds the standard DefaultServlet, JSP processing, and welcome
++ * files.
++ *
++ * In complex cases, you may prefer to use the ordinary Tomcat API to create
++ * webapp contexts; for example, you might need to install a custom Loader
++ * before the call to {@link Host#addChild(Container)}. To replicate the basic
++ * behavior of the <pre>addWebapp</pre> methods, you may want to call two
++ * methods of this class: {@link #noDefaultWebXmlPath()} and
++ * {@link #getDefaultWebXmlListener()}.
++ *
++ * {@link #getDefaultRealm()} returns the simple security realm.
++ *
++ * {@link #getDefaultWebXmlListener()} returns a {@link LifecycleListener} that
++ * adds the standard DefaultServlet, JSP processing, and welcome files. If you
++ * add this listener, you must prevent Tomcat from applying any standard global
++ * web.xml with ...
++ *
++ * {@link #noDefaultWebXmlPath()} returns a dummy pathname to configure to
++ * prevent {@link ContextConfig} from trying to apply a global web.xml file.
++ *
++ * This class provides a main() and few simple CLI arguments,
++ * see setters for doc. It can be used for simple tests and
++ * demo.
++ *
++ * @see <a href="http://svn.apache.org/repos/asf/tomcat/trunk/test/org/apache/catalina/startup/TestTomcat.java">TestTomcat</a>
++ * @author Costin Manolache
++ */
++public class Tomcat {
++
++// // Some logging implementations use weak references for loggers so there is
++// // the possibility that logging configuration could be lost if GC runs just
++// // after Loggers are configured but before they are used. The purpose of
++// // this Map is to retain strong references to explicitly configured loggers
++// // so that configuration is not lost.
++// private final Map<String, Logger> pinnedLoggers = new HashMap<String, Logger>();
++
++ // Single engine, service, server, connector - few cases need more,
++ // they can use server.xml
++ protected StandardServer server;
++ protected StandardService service;
++ protected StandardEngine engine;
++ protected Connector connector; // for more - customize the classes
++
++ // To make it a bit easier to config for the common case
++ // ( one host, one context ).
++ protected Host host;
++
++ // TODO: it's easy to add support for more hosts - but is it
++ // really needed ?
++
++ // TODO: allow use of in-memory connector
++
++ protected int port = 8080;
++ protected String hostname = "localhost";
++ protected String basedir;
++
++ private volatile boolean initialized;
++ private volatile boolean started;
++
++// // Default in-memory realm, will be set by default on the Engine. Can be
++// // replaced at engine level or over-ridden at Host or Context level
++// @Deprecated // Will be removed in Tomcat 8.0.x.
++// protected Realm defaultRealm;
++// private final Map<String, String> userPass = new HashMap<String, String>();
++// private final Map<String, List<String>> userRoles =
++// new HashMap<String, List<String>>();
++// private final Map<String, Principal> userPrincipals =
++// new HashMap<String, Principal>();
++
++ public Tomcat() {
++ // NOOP
++ }
++
++ /**
++ * Tomcat needs a directory for temp files. This should be the
++ * first method called.
++ *
++ * By default, if this method is not called, we use:
++ * - system properties - catalina.base, catalina.home
++ * - $HOME/tomcat.$PORT
++ * ( /tmp doesn't seem a good choice for security ).
++ *
++ *
++ * TODO: better default ? Maybe current dir ?
++ * TODO: disable work dir if not needed ( no jsp, etc ).
++ */
++ public void setBaseDir(String basedir) {
++ this.basedir = basedir;
++ }
++
++ /**
++ * Set the port for the default connector. Must
++ * be called before start().
++ */
++ public void setPort(int port) {
++ this.port = port;
++ }
++
++ /**
++ * The the hostname of the default host, default is
++ * 'localhost'.
++ */
++ public void setHostname(String s) {
++ hostname = s;
++ }
++
++ /**
++ * This is equivalent to adding a web application to Tomcat's webapps
++ * directory. The equivalent of the default web.xml will be applied to the
++ * web application and any WEB-INF/web.xml and META-INF/context.xml packaged
++ * with the application will be processed normally. Normal web fragment and
++ * {@link javax.servlet.ServletContainerInitializer} processing will be
++ * applied.
++ *
++ * @throws ServletException
++ */
++ public Context addWebapp(String contextPath, String docBase) throws ServletException {
++ return addWebapp(getHost(), contextPath, docBase);
++ }
++
++
++ /**
++ * Add a context - programmatic mode, no web.xml used.
++ *
++ * API calls equivalent with web.xml:
++ *
++ * context-param
++ * ctx.addParameter("name", "value");
++ *
++ *
++ * error-page
++ * ErrorPage ep = new ErrorPage();
++ * ep.setErrorCode(500);
++ * ep.setLocation("/error.html");
++ * ctx.addErrorPage(ep);
++ *
++ * ctx.addMimeMapping("ext", "type");
++ *
++ * Note: If you reload the Context, all your configuration will be lost. If
++ * you need reload support, consider using a LifecycleListener to provide
++ * your configuration.
++ *
++ * TODO: add the rest
++ *
++ * @param contextPath "" for root context.
++ * @param docBase base dir for the context, for static files. Must exist,
++ * relative to the server home
++ */
++ public Context addContext(String contextPath, String docBase) {
++ return addContext(getHost(), contextPath, docBase);
++ }
++
++// /**
++// * Equivalent with
++// * <servlet><servlet-name><servlet-class>.
++// *
++// * In general it is better/faster to use the method that takes a
++// * Servlet as param - this one can be used if the servlet is not
++// * commonly used, and want to avoid loading all deps.
++// * ( for example: jsp servlet )
++// *
++// * You can customize the returned servlet, ex:
++// *
++// * wrapper.addInitParameter("name", "value");
++// *
++// * @param contextPath Context to add Servlet to
++// * @param servletName Servlet name (used in mappings)
++// * @param servletClass The class to be used for the Servlet
++// * @return The wrapper for the servlet
++// */
++// public Wrapper addServlet(String contextPath,
++// String servletName,
++// String servletClass) {
++// Container ctx = getHost().findChild(contextPath);
++// return addServlet((Context) ctx, servletName, servletClass);
++// }
++
++ /**
++ * Static version of {@link #addServlet(String, String, String)}
++ * @param ctx Context to add Servlet to
++ * @param servletName Servlet name (used in mappings)
++ * @param servletClass The class to be used for the Servlet
++ * @return The wrapper for the servlet
++ */
++ public static Wrapper addServlet(Context ctx,
++ String servletName,
++ String servletClass) {
++ // will do class for name and set init params
++ Wrapper sw = ctx.createWrapper();
++ sw.setServletClass(servletClass);
++ sw.setName(servletName);
++ ctx.addChild(sw);
++
++ return sw;
++ }
++
++// /**
++// * Add an existing Servlet to the context with no class.forName or
++// * initialisation.
++// * @param contextPath Context to add Servlet to
++// * @param servletName Servlet name (used in mappings)
++// * @param servlet The Servlet to add
++// * @return The wrapper for the servlet
++// */
++// public Wrapper addServlet(String contextPath,
++// String servletName,
++// Servlet servlet) {
++// Container ctx = getHost().findChild(contextPath);
++// return addServlet((Context) ctx, servletName, servlet);
++// }
++
++ /**
++ * Static version of {@link #addServlet(String, String, Servlet)}.
++ * @param ctx Context to add Servlet to
++ * @param servletName Servlet name (used in mappings)
++ * @param servlet The Servlet to add
++ * @return The wrapper for the servlet
++ */
++ public static Wrapper addServlet(Context ctx,
++ String servletName,
++ Servlet servlet) {
++ // will do class for name and set init params
++ Wrapper sw = new ExistingStandardWrapper(servlet);
++ sw.setName(servletName);
++ ctx.addChild(sw);
++
++ return sw;
++ }
++
++
++ /**
++ * Initialise the server.
++ *
++ * @throws LifecycleException
++ */
++ public void init() throws LifecycleException {
++ getServer();
++ getConnector();
++ if (!initialized) {
++ initialized = true;
++ try {
++ server.init();
++ } catch (LifecycleException e) {
++ throw e;
++ } catch (Exception e) {
++ throw new LifecycleException(e);
++ }
++ }
++ }
++
++
++ /**
++ * Start the server.
++ *
++ * @throws LifecycleException
++ */
++ public void start() throws LifecycleException {
++ if (!started) {
++ init();
++ started = true;
++ server.start();
++ }
++ }
++
++ /**
++ * Stop the server.
++ *
++ * @throws LifecycleException
++ */
++ public void stop() throws LifecycleException {
++ if (started) {
++ started = false;
++ server.stop();
++ }
++ }
++
++
++ /**
++ * Destroy the server. This object cannot be used once this method has been
++ * called.
++ */
++ public void destroy() throws LifecycleException {
++ if (initialized) {
++ stop();
++ initialized = false;
++ // server.destroy();
++ // Could null out objects here
++ }
++ }
++
++// /**
++// * Add a user for the in-memory realm. All created apps use this
++// * by default, can be replaced using setRealm().
++// *
++// */
++// public void addUser(String user, String pass) {
++// userPass.put(user, pass);
++// }
++//
++// /**
++// * @see #addUser(String, String)
++// */
++// public void addRole(String user, String role) {
++// List<String> roles = userRoles.get(user);
++// if (roles == null) {
++// roles = new ArrayList<String>();
++// userRoles.put(user, roles);
++// }
++// roles.add(role);
++// }
++
++ // ------- Extra customization -------
++ // You can tune individual tomcat objects, using internal APIs
++
++ /**
++ * Get the default http connector. You can set more
++ * parameters - the port is already initialized.
++ *
++ * Alternatively, you can construct a Connector and set any params,
++ * then call addConnector(Connector)
++ *
++ * @return A connector object that can be customized
++ */
++ public Connector getConnector() {
++ getServer();
++ if (connector != null) {
++ return connector;
++ }
++
++ // The same as in standard Tomcat configuration.
++ // This creates an APR HTTP connector if AprLifecycleListener has been
++ // configured (created) and Tomcat Native library is available.
++ // Otherwise it creates a BIO HTTP connector (Http11Protocol).
++ try {
++ connector = new Connector("HTTP/1.1");
++ } catch (RuntimeException e) {
++ throw e;
++ } catch (Exception e) {
++ // Never happens. Connector() declares that it can throw
++ // an Exception, but never throws one.
++ throw new RuntimeException(e);
++ }
++ connector.setPort(port);
++ service.addConnector( connector );
++ return connector;
++ }
++
++ public void setConnector(Connector connector) {
++ this.connector = connector;
++ }
++
++ /**
++ * Get the service object. Can be used to add more
++ * connectors and few other global settings.
++ */
++ public Service getService() {
++ getServer();
++ return service;
++ }
++
++ /**
++ * Sets the current host - all future webapps will
++ * be added to this host. When tomcat starts, the
++ * host will be the default host.
++ *
++ * @param host
++ */
++ public void setHost(Host host) {
++ this.host = host;
++ }
++
++ public Host getHost() {
++ if (host == null) {
++ host = new StandardHost();
++ host.setName(hostname);
++
++ getEngine().addChild( host );
++ }
++ return host;
++ }
++
++// /**
++// * Set a custom realm for auth. If not called, a simple
++// * default will be used, using an internal map.
++// *
++// * Must be called before adding a context.
++// *
++// * @deprecated Will be removed in Tomcat 8.0.x.
++// */
++// @Deprecated
++// public void setDefaultRealm(Realm realm) {
++// defaultRealm = realm;
++// }
++//
++
++ /**
++ * Access to the engine, for further customization.
++ */
++ public Engine getEngine() {
++ if(engine == null ) {
++ getServer();
++ engine = new StandardEngine();
++ engine.setName( "Tomcat" );
++ engine.setDefaultHost(hostname);
++ // @Deprecated
++ // if (defaultRealm == null) {
++ // initSimpleAuth();
++ // }
++ // engine.setRealm(defaultRealm);
++ service.setContainer(engine);
++ }
++ return engine;
++ }
++
++ /**
++ * Get the server object. You can add listeners and few more
++ * customizations. JNDI is disabled by default.
++ */
++ public Server getServer() {
++
++ if (server != null) {
++ return server;
++ }
++
++ initBaseDir();
++
++ System.setProperty("catalina.useNaming", "false");
++
++ server = new StandardServer();
++ server.setPort(-1);
++
++ service = new StandardService();
++ service.setName("Tomcat");
++ server.addService(service);
++ return server;
++ }
++
++ public Context addContext(Host host, String contextPath, String dir) {
++ return addContext(host, contextPath, contextPath, dir);
++ }
++
++ private Context addContext(Host host, String contextPath, String contextName,
++ String dir) {
++// silence(host, contextPath);
++ Context ctx = createContext(host, contextPath);
++ ctx.setName(contextName);
++ ctx.setPath(contextPath);
++ ctx.setDocBase(dir);
++ ((Lifecycle) ctx).addLifecycleListener(new FixContextListener());
++
++ if (host == null) {
++ getHost().addChild(ctx);
++ } else {
++ host.addChild(ctx);
++ }
++ return ctx;
++ }
++
++ public Context addWebapp(Host host, String contextPath, String docBase) {
++ return addWebapp(host, contextPath, contextPath, docBase);
++ }
++
++ /**
++ * @see #addWebapp(String, String)
++ *
++ * @param name Ignored. The contextPath will be used
++ *
++ * @deprecated Use {@link #addWebapp(Host, String, String)}
++ */
++ @Deprecated
++ private Context addWebapp(Host host, String contextPath, String name, String docBase) {
++// silence(host, contextPath);
++
++ Context ctx = createContext(host, contextPath);
++ ctx.setPath(contextPath);
++ ctx.setDocBase(docBase);
++
++ ((Lifecycle) ctx).addLifecycleListener(new DefaultWebXmlListener());
++ ctx.setConfigFile(getWebappConfigFile(docBase, contextPath));
++
++ ContextConfig ctxCfg = new ContextConfig();
++ ((Lifecycle) ctx).addLifecycleListener(ctxCfg);
++
++// // prevent it from looking ( if it finds one - it'll have dup error )
++// ctxCfg.setDefaultWebXml(noDefaultWebXmlPath());
++
++ if (host == null) {
++ getHost().addChild(ctx);
++ } else {
++ host.addChild(ctx);
++ }
++
++ return ctx;
++ }
++
++// /**
++// * Return a listener that provides the required configuration items for JSP
++// * processing. From the standard Tomcat global web.xml. Pass this to
++// * {@link Context#addLifecycleListener(LifecycleListener)} and then pass the
++// * result of {@link #noDefaultWebXmlPath()} to
++// * {@link ContextConfig#setDefaultWebXml(String)}.
++// * @return a listener object that configures default JSP processing.
++// */
++// public LifecycleListener getDefaultWebXmlListener() {
++// return new DefaultWebXmlListener();
++// }
++//
++// /**
++// * @return a pathname to pass to
++// * {@link ContextConfig#setDefaultWebXml(String)} when using
++// * {@link #getDefaultWebXmlListener()}.
++// */
++// public String noDefaultWebXmlPath() {
++// return Constants.NoDefaultWebXml;
++// }
++//
++// /**
++// * For complex configurations, this accessor allows callers of this class
++// * to obtain the simple realm created by default.
++// * @return the simple in-memory realm created by default.
++// * @deprecated Will be removed in Tomcat 8.0.x
++// */
++// @Deprecated
++// public Realm getDefaultRealm() {
++// if (defaultRealm == null) {
++// initSimpleAuth();
++// }
++// return defaultRealm;
++// }
++//
++//
++// // ---------- Helper methods and classes -------------------
++//
++// /**
++// * Create an in-memory realm. You can replace it for contexts with a real
++// * one. The Realm created here will be added to the Engine by default and
++// * may be replaced at the Engine level or over-ridden (as per normal Tomcat
++// * behaviour) at the Host or Context level.
++// * @deprecated Will be removed in Tomcat 8.0.x
++// */
++// @Deprecated
++// protected void initSimpleAuth() {
++// defaultRealm = new RealmBase() {
++// @Override
++// protected String getName() {
++// return "Simple";
++// }
++//
++// @Override
++// protected String getPassword(String username) {
++// return userPass.get(username);
++// }
++//
++// @Override
++// protected Principal getPrincipal(String username) {
++// Principal p = userPrincipals.get(username);
++// if (p == null) {
++// String pass = userPass.get(username);
++// if (pass != null) {
++// p = new GenericPrincipal(username, pass,
++// userRoles.get(username));
++// userPrincipals.put(username, p);
++// }
++// }
++// return p;
++// }
++//
++// };
++// }
++
++ protected void initBaseDir() {
++ String catalinaHome = System.getProperty(Globals.CATALINA_HOME_PROP);
++ if (basedir == null) {
++ basedir = System.getProperty(Globals.CATALINA_BASE_PROP);
++ }
++ if (basedir == null) {
++ basedir = catalinaHome;
++ }
++ if (basedir == null) {
++ // Create a temp dir.
++ basedir = System.getProperty("user.dir") + "/tomcat." + port;
++ File home = new File(basedir);
++ home.mkdir();
++ if (!home.isAbsolute()) {
++ try {
++ basedir = home.getCanonicalPath();
++ } catch (IOException e) {
++ basedir = home.getAbsolutePath();
++ }
++ }
++ }
++ if (catalinaHome == null) {
++ System.setProperty(Globals.CATALINA_HOME_PROP, basedir);
++ }
++ System.setProperty(Globals.CATALINA_BASE_PROP, basedir);
++ }
++
++// Not needed. See BZ 58905.
++//
++// static final String[] silences = new String[] {
++// "org.apache.coyote.http11.Http11Protocol",
++// "org.apache.catalina.core.StandardService",
++// "org.apache.catalina.core.StandardEngine",
++// "org.apache.catalina.startup.ContextConfig",
++// "org.apache.catalina.core.ApplicationContext",
++// "org.apache.catalina.core.AprLifecycleListener"
++// };
++//
++// /**
++// * Controls if the loggers will be silenced or not.
++// * @param silent <code>true</code> sets the log level to WARN for the
++// * loggers that log information on Tomcat start up. This
++// * prevents the usual startup information being logged.
++// * <code>false</code> sets the log level to the default
++// * level of INFO.
++// */
++// public void setSilent(boolean silent) {
++// for (String s : silences) {
++// Logger logger = Logger.getLogger(s);
++// pinnedLoggers.put(s, logger);
++// if (silent) {
++// logger.setLevel(Level.WARNING);
++// } else {
++// logger.setLevel(Level.INFO);
++// }
++// }
++// }
++//
++// private void silence(Host host, String ctx) {
++// String loggerName = getLoggerName(host, ctx);
++// Logger logger = Logger.getLogger(loggerName);
++// pinnedLoggers.put(loggerName, logger);
++// logger.setLevel(Level.WARNING);
++// }
++//
++// private String getLoggerName(Host host, String ctx) {
++// String loggerName = "org.apache.catalina.core.ContainerBase.[default].[";
++// if (host == null) {
++// loggerName += getHost().getName();
++// } else {
++// loggerName += host.getName();
++// }
++// loggerName += "].[";
++// loggerName += ctx;
++// loggerName += "]";
++// return loggerName;
++// }
++
++ /**
++ * Create the configured {@link Context} for the given <code>host</code>.
++ * The default constructor of the class that was configured with
++ * {@link StandardHost#setContextClass(String)} will be used
++ *
++ * @param host
++ * host for which the {@link Context} should be created, or
++ * <code>null</code> if default host should be used
++ * @param url
++ * path of the webapp which should get the {@link Context}
++ * @return newly created {@link Context}
++ */
++ private Context createContext(Host host, String url) {
++ String contextClass = StandardContext.class.getName();
++ if (host == null) {
++ host = this.getHost();
++ }
++ if (host instanceof StandardHost) {
++ contextClass = ((StandardHost) host).getContextClass();
++ }
++ try {
++ return (Context) Class.forName(contextClass).getConstructor()
++ .newInstance();
++ } catch (InstantiationException e) {
++ throw new IllegalArgumentException(
++ "Can't instantiate context-class " + contextClass
++ + " for host " + host + " and url "
++ + url, e);
++ } catch (IllegalAccessException e) {
++ throw new IllegalArgumentException(
++ "Can't instantiate context-class " + contextClass
++ + " for host " + host + " and url "
++ + url, e);
++ } catch (IllegalArgumentException e) {
++ throw new IllegalArgumentException(
++ "Can't instantiate context-class " + contextClass
++ + " for host " + host + " and url "
++ + url, e);
++ } catch (InvocationTargetException e) {
++ throw new IllegalArgumentException(
++ "Can't instantiate context-class " + contextClass
++ + " for host " + host + " and url "
++ + url, e);
++ } catch (NoSuchMethodException e) {
++ throw new IllegalArgumentException(
++ "Can't instantiate context-class " + contextClass
++ + " for host " + host + " and url "
++ + url, e);
++ } catch (SecurityException e) {
++ throw new IllegalArgumentException(
++ "Can't instantiate context-class " + contextClass
++ + " for host " + host + " and url "
++ + url, e);
++ } catch (ClassNotFoundException e) {
++ throw new IllegalArgumentException(
++ "Can't instantiate context-class " + contextClass
++ + " for host " + host + " and url "
++ + url, e);
++ }
++ }
++
++ /**
++ * Enables JNDI naming which is disabled by default. Server must implement
++ * {@link Lifecycle} in order for the {@link NamingContextListener} to be
++ * used.
++ *
++ */
++ public void enableNaming() {
++ // Make sure getServer() has been called as that is where naming is
++ // disabled
++ getServer();
++ server.addLifecycleListener(new NamingContextListener());
++
++ System.setProperty("catalina.useNaming", "true");
++
++ String value = "org.apache.naming";
++ String oldValue =
++ System.getProperty(javax.naming.Context.URL_PKG_PREFIXES);
++ if (oldValue != null) {
++ if (oldValue.contains(value)) {
++ value = oldValue;
++ } else {
++ value = value + ":" + oldValue;
++ }
++ }
++ System.setProperty(javax.naming.Context.URL_PKG_PREFIXES, value);
++
++ value = System.getProperty
++ (javax.naming.Context.INITIAL_CONTEXT_FACTORY);
++ if (value == null) {
++ System.setProperty
++ (javax.naming.Context.INITIAL_CONTEXT_FACTORY,
++ "org.apache.naming.java.javaURLContextFactory");
++ }
++ }
++
++// /**
++// * Provide default configuration for a context. This is the programmatic
++// * equivalent of the default web.xml.
++// *
++// * TODO: in normal Tomcat, if default-web.xml is not found, use this
++// * method
++// *
++// * @param contextPath The context to set the defaults for
++// */
++// public void initWebappDefaults(String contextPath) {
++// Container ctx = getHost().findChild(contextPath);
++// initWebappDefaults((Context) ctx);
++// }
++
++ /**
++ * Static version of {@link #initWebappDefaults(String)}
++ * @param ctx The context to set the defaults for
++ */
++ public static void initWebappDefaults(Context ctx) {
++ // Default servlet
++ Wrapper servlet = addServlet(
++ ctx, "default", "org.apache.catalina.servlets.DefaultServlet");
++ servlet.setLoadOnStartup(1);
++ //servlet.setOverridable(true);
++
++ // JSP servlet (by class name - to avoid loading all deps)
++ servlet = addServlet(
++ ctx, "jsp", "org.apache.jasper.servlet.JspServlet");
++ servlet.addInitParameter("fork", "false");
++ servlet.setLoadOnStartup(3);
++ //servlet.setOverridable(true);
++
++ // Servlet mappings
++ ctx.addServletMapping("/", "default");
++ ctx.addServletMapping("*.jsp", "jsp");
++ ctx.addServletMapping("*.jspx", "jsp");
++
++ // Sessions
++ ctx.setSessionTimeout(30);
++
++ // MIME mappings
++ for (int i = 0; i < DEFAULT_MIME_MAPPINGS.length;) {
++ ctx.addMimeMapping(DEFAULT_MIME_MAPPINGS[i++],
++ DEFAULT_MIME_MAPPINGS[i++]);
++ }
++
++ // Welcome files
++ ctx.addWelcomeFile("index.html");
++ ctx.addWelcomeFile("index.htm");
++ ctx.addWelcomeFile("index.jsp");
++ }
++
++
++ /**
++ * Fix startup sequence - required if you don't use web.xml.
++ *
++ * The start() method in context will set 'configured' to false - and
++ * expects a listener to set it back to true.
++ */
++ public static class FixContextListener implements LifecycleListener {
++
++ public void lifecycleEvent(LifecycleEvent event) {
++ try {
++ Context context = (Context) event.getLifecycle();
++ // Using START_EVENT, Tomcat 7+ uses CONFIGURE_START_EVENT here.
++ if (event.getType().equals(Lifecycle.START_EVENT)) {
++ context.setConfigured(true);
++ }
++// Not needed. Tomcat 6 does not support @ServletSecurity annotations.
++// // LoginConfig is required to process @ServletSecurity
++// // annotations
++// if (context.getLoginConfig() == null) {
++// context.setLoginConfig(
++// new LoginConfig("NONE", null, null, null));
++// context.getPipeline().addValve(new NonLoginAuthenticator());
++// }
++ } catch (ClassCastException e) {
++ return;
++ }
++ }
++
++ }
++
++
++ /**
++ * Fix reload - required if reloading and using programmatic configuration.
++ * When a context is reloaded, any programmatic configuration is lost. This
++ * listener sets the equivalent of conf/web.xml when the context starts.
++ */
++ public static class DefaultWebXmlListener implements LifecycleListener {
++ public void lifecycleEvent(LifecycleEvent event) {
++ if (Lifecycle.BEFORE_START_EVENT.equals(event.getType())) {
++ initWebappDefaults((Context) event.getLifecycle());
++ }
++ }
++ }
++
++
++ /**
++ * Helper class for wrapping existing servlets. This disables servlet
++ * lifecycle and normal reloading, but also reduces overhead and provide
++ * more direct control over the servlet.
++ */
++ public static class ExistingStandardWrapper extends StandardWrapper {
++ private final Servlet existing;
++ private boolean instanceInitialized = false;
++ private static final long serialVersionUID = 1L;
++
++ @SuppressWarnings("deprecation")
++ public ExistingStandardWrapper( Servlet existing ) {
++ this.existing = existing;
++ if (existing instanceof javax.servlet.SingleThreadModel) {
++ singleThreadModel = true;
++ instancePool = new Stack<Servlet>();
++ }
++ }
++ @Override
++ public synchronized Servlet loadServlet() throws ServletException {
++ if (singleThreadModel) {
++ Servlet instance;
++ try {
++ instance = existing.getClass().newInstance();
++ } catch (InstantiationException e) {
++ throw new ServletException(e);
++ } catch (IllegalAccessException e) {
++ throw new ServletException(e);
++ }
++ instance.init(facade);
++ return instance;
++ } else {
++ if (!instanceInitialized) {
++ existing.init(facade);
++ instanceInitialized = true;
++ }
++ return existing;
++ }
++ }
++ @Override
++ public long getAvailable() {
++ return 0;
++ }
++ @Override
++ public boolean isUnavailable() {
++ return false;
++ }
++ @Override
++ public Servlet getServlet() {
++ return existing;
++ }
++ @Override
++ public String getServletClass() {
++ return existing.getClass().getName();
++ }
++ }
++
++ /**
++ * TODO: would a properties resource be better ? Or just parsing
++ * /etc/mime.types ?
++ * This is needed because we don't use the default web.xml, where this
++ * is encoded.
++ */
++ private static final String[] DEFAULT_MIME_MAPPINGS = {
++ "abs", "audio/x-mpeg",
++ "ai", "application/postscript",
++ "aif", "audio/x-aiff",
++ "aifc", "audio/x-aiff",
++ "aiff", "audio/x-aiff",
++ "aim", "application/x-aim",
++ "art", "image/x-jg",
++ "asf", "video/x-ms-asf",
++ "asx", "video/x-ms-asf",
++ "au", "audio/basic",
++ "avi", "video/x-msvideo",
++ "avx", "video/x-rad-screenplay",
++ "bcpio", "application/x-bcpio",
++ "bin", "application/octet-stream",
++ "bmp", "image/bmp",
++ "body", "text/html",
++ "cdf", "application/x-cdf",
++ "cer", "application/pkix-cert",
++ "class", "application/java",
++ "cpio", "application/x-cpio",
++ "csh", "application/x-csh",
++ "css", "text/css",
++ "dib", "image/bmp",
++ "doc", "application/msword",
++ "dtd", "application/xml-dtd",
++ "dv", "video/x-dv",
++ "dvi", "application/x-dvi",
++ "eps", "application/postscript",
++ "etx", "text/x-setext",
++ "exe", "application/octet-stream",
++ "gif", "image/gif",
++ "gtar", "application/x-gtar",
++ "gz", "application/x-gzip",
++ "hdf", "application/x-hdf",
++ "hqx", "application/mac-binhex40",
++ "htc", "text/x-component",
++ "htm", "text/html",
++ "html", "text/html",
++ "ief", "image/ief",
++ "jad", "text/vnd.sun.j2me.app-descriptor",
++ "jar", "application/java-archive",
++ "java", "text/x-java-source",
++ "jnlp", "application/x-java-jnlp-file",
++ "jpe", "image/jpeg",
++ "jpeg", "image/jpeg",
++ "jpg", "image/jpeg",
++ "js", "application/javascript",
++ "jsf", "text/plain",
++ "jspf", "text/plain",
++ "kar", "audio/midi",
++ "latex", "application/x-latex",
++ "m3u", "audio/x-mpegurl",
++ "mac", "image/x-macpaint",
++ "man", "text/troff",
++ "mathml", "application/mathml+xml",
++ "me", "text/troff",
++ "mid", "audio/midi",
++ "midi", "audio/midi",
++ "mif", "application/x-mif",
++ "mov", "video/quicktime",
++ "movie", "video/x-sgi-movie",
++ "mp1", "audio/mpeg",
++ "mp2", "audio/mpeg",
++ "mp3", "audio/mpeg",
++ "mp4", "video/mp4",
++ "mpa", "audio/mpeg",
++ "mpe", "video/mpeg",
++ "mpeg", "video/mpeg",
++ "mpega", "audio/x-mpeg",
++ "mpg", "video/mpeg",
++ "mpv2", "video/mpeg2",
++ "nc", "application/x-netcdf",
++ "oda", "application/oda",
++ "odb", "application/vnd.oasis.opendocument.database",
++ "odc", "application/vnd.oasis.opendocument.chart",
++ "odf", "application/vnd.oasis.opendocument.formula",
++ "odg", "application/vnd.oasis.opendocument.graphics",
++ "odi", "application/vnd.oasis.opendocument.image",
++ "odm", "application/vnd.oasis.opendocument.text-master",
++ "odp", "application/vnd.oasis.opendocument.presentation",
++ "ods", "application/vnd.oasis.opendocument.spreadsheet",
++ "odt", "application/vnd.oasis.opendocument.text",
++ "otg", "application/vnd.oasis.opendocument.graphics-template",
++ "oth", "application/vnd.oasis.opendocument.text-web",
++ "otp", "application/vnd.oasis.opendocument.presentation-template",
++ "ots", "application/vnd.oasis.opendocument.spreadsheet-template ",
++ "ott", "application/vnd.oasis.opendocument.text-template",
++ "ogx", "application/ogg",
++ "ogv", "video/ogg",
++ "oga", "audio/ogg",
++ "ogg", "audio/ogg",
++ "spx", "audio/ogg",
++ "flac", "audio/flac",
++ "anx", "application/annodex",
++ "axa", "audio/annodex",
++ "axv", "video/annodex",
++ "xspf", "application/xspf+xml",
++ "pbm", "image/x-portable-bitmap",
++ "pct", "image/pict",
++ "pdf", "application/pdf",
++ "pgm", "image/x-portable-graymap",
++ "pic", "image/pict",
++ "pict", "image/pict",
++ "pls", "audio/x-scpls",
++ "png", "image/png",
++ "pnm", "image/x-portable-anymap",
++ "pnt", "image/x-macpaint",
++ "ppm", "image/x-portable-pixmap",
++ "ppt", "application/vnd.ms-powerpoint",
++ "pps", "application/vnd.ms-powerpoint",
++ "ps", "application/postscript",
++ "psd", "image/vnd.adobe.photoshop",
++ "qt", "video/quicktime",
++ "qti", "image/x-quicktime",
++ "qtif", "image/x-quicktime",
++ "ras", "image/x-cmu-raster",
++ "rdf", "application/rdf+xml",
++ "rgb", "image/x-rgb",
++ "rm", "application/vnd.rn-realmedia",
++ "roff", "text/troff",
++ "rtf", "application/rtf",
++ "rtx", "text/richtext",
++ "sh", "application/x-sh",
++ "shar", "application/x-shar",
++ /*"shtml", "text/x-server-parsed-html",*/
++ "sit", "application/x-stuffit",
++ "snd", "audio/basic",
++ "src", "application/x-wais-source",
++ "sv4cpio", "application/x-sv4cpio",
++ "sv4crc", "application/x-sv4crc",
++ "svg", "image/svg+xml",
++ "svgz", "image/svg+xml",
++ "swf", "application/x-shockwave-flash",
++ "t", "text/troff",
++ "tar", "application/x-tar",
++ "tcl", "application/x-tcl",
++ "tex", "application/x-tex",
++ "texi", "application/x-texinfo",
++ "texinfo", "application/x-texinfo",
++ "tif", "image/tiff",
++ "tiff", "image/tiff",
++ "tr", "text/troff",
++ "tsv", "text/tab-separated-values",
++ "txt", "text/plain",
++ "ulw", "audio/basic",
++ "ustar", "application/x-ustar",
++ "vxml", "application/voicexml+xml",
++ "xbm", "image/x-xbitmap",
++ "xht", "application/xhtml+xml",
++ "xhtml", "application/xhtml+xml",
++ "xls", "application/vnd.ms-excel",
++ "xml", "application/xml",
++ "xpm", "image/x-xpixmap",
++ "xsl", "application/xml",
++ "xslt", "application/xslt+xml",
++ "xul", "application/vnd.mozilla.xul+xml",
++ "xwd", "image/x-xwindowdump",
++ "vsd", "application/vnd.visio",
++ "wav", "audio/x-wav",
++ "wbmp", "image/vnd.wap.wbmp",
++ "wml", "text/vnd.wap.wml",
++ "wmlc", "application/vnd.wap.wmlc",
++ "wmls", "text/vnd.wap.wmlsc",
++ "wmlscriptc", "application/vnd.wap.wmlscriptc",
++ "wmv", "video/x-ms-wmv",
++ "wrl", "model/vrml",
++ "wspolicy", "application/wspolicy+xml",
++ "Z", "application/x-compress",
++ "z", "application/x-compress",
++ "zip", "application/zip"
++ };
++
++ protected String getWebappConfigFile(String path, @SuppressWarnings("unused") String contextPath) {
++ File docBase = new File(path);
++ if (docBase.isDirectory()) {
++ return getWebappConfigFileFromDirectory(docBase);
++ } else {
++ // Reading context.xml from a war file without copying it
++ // is not implemented in Tomcat 6. (BZ 48662, r928380)
++ // return getWebappConfigFileFromJar(docBase, contextPath);
++ return null;
++ }
++ }
++
++ private String getWebappConfigFileFromDirectory(File docBase) {
++ String result = null;
++ File webAppContextXml = new File(docBase, Constants.ApplicationContextXml);
++ if (webAppContextXml.exists()) {
++ result = webAppContextXml.getAbsolutePath();
++ }
++ return result;
++ }
++
++// private URL getWebappConfigFileFromJar(File docBase, String url) {
++// URL result = null;
++// JarFile jar = null;
++// try {
++// jar = new JarFile(docBase);
++// JarEntry entry = jar.getJarEntry(Constants.ApplicationContextXml);
++// if (entry != null) {
++// result = new URL("jar:" + docBase.toURI().toString() + "!/"
++// + Constants.ApplicationContextXml);
++// }
++// } catch (IOException e) {
++// Logger.getLogger(getLoggerName(getHost(), url)).log(Level.WARNING,
++// "Unable to determine web application context.xml " + docBase, e);
++// } finally {
++// if (jar != null) {
++// try {
++// jar.close();
++// } catch (IOException e) {
++// // ignore
++// }
++// }
++// }
++// return result;
++// }
++}
+
+Property changes on: test/org/apache/catalina/startup/Tomcat.java
+___________________________________________________________________
+Added: svn:eol-style
+## -0,0 +1 ##
++native
+\ No newline at end of property
+Index: test/org/apache/catalina/startup/FastNonSecureRandom.java
+===================================================================
+--- test/org/apache/catalina/startup/FastNonSecureRandom.java (.../trunk) (revision 0)
++++ test/org/apache/catalina/startup/FastNonSecureRandom.java (.../branches/tomcat6-testing_20160106) (revision 1726111)
+@@ -0,0 +1,60 @@
++/*
++ * Licensed to the Apache Software Foundation (ASF) under one or more
++ * contributor license agreements. See the NOTICE file distributed with
++ * this work for additional information regarding copyright ownership.
++ * The ASF licenses this file to You under the Apache License, Version 2.0
++ * (the "License"); you may not use this file except in compliance with
++ * the License. You may obtain a copy of the License at
++ *
++ * http://www.apache.org/licenses/LICENSE-2.0
++ *
++ * Unless required by applicable law or agreed to in writing, software
++ * distributed under the License is distributed on an "AS IS" BASIS,
++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ * See the License for the specific language governing permissions and
++ * limitations under the License.
++ */
++package org.apache.catalina.startup;
++
++import java.security.SecureRandom;
++import java.util.Random;
++
++public class FastNonSecureRandom extends SecureRandom {
++
++ private static final long serialVersionUID = 1L;
++
++ private final Random random = new Random();
++
++ @Override
++ public String getAlgorithm() {
++ return "INSECURE";
++ }
++
++ @Override
++ public synchronized void setSeed(byte[] seed) {
++ // Not implemented
++ }
++
++ @Override
++ public synchronized void setSeed(long seed) {
++ // The super class constructor calls this method earlier than our
++ // fields are initialized. Ignore the call.
++ if (random == null) {
++ return;
++ }
++ random.setSeed(seed);
++ }
++
++ @Override
++ public synchronized void nextBytes(byte[] bytes) {
++ random.nextBytes(bytes);
++ }
++
++ @Override
++ public byte[] generateSeed(int numBytes) {
++ byte[] value = new byte[numBytes];
++ nextBytes(value);
++ return value;
++ }
++
++}
+\ No newline at end of file
+
+Property changes on: test/org/apache/catalina/startup/FastNonSecureRandom.java
+___________________________________________________________________
+Added: svn:eol-style
+## -0,0 +1 ##
++native
+\ No newline at end of property
+Index: test/org/apache/catalina/startup/TomcatBaseTest.java
+===================================================================
+--- test/org/apache/catalina/startup/TomcatBaseTest.java (.../trunk) (revision 0)
++++ test/org/apache/catalina/startup/TomcatBaseTest.java (.../branches/tomcat6-testing_20160106) (revision 1726111)
+@@ -0,0 +1,796 @@
++/*
++ * Licensed to the Apache Software Foundation (ASF) under one or more
++ * contributor license agreements. See the NOTICE file distributed with
++ * this work for additional information regarding copyright ownership.
++ * The ASF licenses this file to You under the Apache License, Version 2.0
++ * (the "License"); you may not use this file except in compliance with
++ * the License. You may obtain a copy of the License at
++ *
++ * http://www.apache.org/licenses/LICENSE-2.0
++ *
++ * Unless required by applicable law or agreed to in writing, software
++ * distributed under the License is distributed on an "AS IS" BASIS,
++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ * See the License for the specific language governing permissions and
++ * limitations under the License.
++ */
++package org.apache.catalina.startup;
++
++import java.io.BufferedInputStream;
++import java.io.File;
++import java.io.IOException;
++import java.io.InputStream;
++import java.io.OutputStream;
++import java.io.PrintWriter;
++import java.net.HttpURLConnection;
++import java.net.InetAddress;
++import java.net.URL;
++import java.util.Enumeration;
++import java.util.HashMap;
++import java.util.List;
++import java.util.Map;
++
++import javax.servlet.ServletContext;
++import javax.servlet.ServletException;
++import javax.servlet.http.HttpServlet;
++import javax.servlet.http.HttpServletRequest;
++import javax.servlet.http.HttpServletResponse;
++import javax.servlet.http.HttpSession;
++
++import static org.junit.Assert.assertNull;
++import static org.junit.Assert.fail;
++
++import org.junit.After;
++import org.junit.Assert;
++import org.junit.Before;
++
++import org.apache.catalina.Container;
++import org.apache.catalina.LifecycleException;
++import org.apache.catalina.Manager;
++import org.apache.catalina.Server;
++import org.apache.catalina.ServerFactory;
++import org.apache.catalina.Service;
++import org.apache.catalina.connector.Connector;
++import org.apache.catalina.core.AprLifecycleListener;
++import org.apache.catalina.core.StandardServer;
++import org.apache.catalina.session.ManagerBase;
++import org.apache.catalina.session.StandardManager;
++import org.apache.catalina.valves.AccessLogValve;
++import org.apache.tomcat.util.buf.ByteChunk;
++
++/**
++ * Base test case that provides a Tomcat instance for each test - mainly so we
++ * don't have to keep writing the cleanup code.
++ */
++public abstract class TomcatBaseTest extends LoggingBaseTest {
++ private Tomcat tomcat;
++ private boolean accessLogEnabled = false;
++
++ public static final String TEMP_DIR = System.getProperty("java.io.tmpdir");
++
++ /**
++ * Make Tomcat instance accessible to sub-classes.
++ */
++ public Tomcat getTomcatInstance() {
++ return tomcat;
++ }
++
++ /**
++ * Sub-classes need to know port so they can connect
++ */
++ public int getPort() {
++ return tomcat.getConnector().getLocalPort();
++ }
++
++ /**
++ * Sub-classes may want to check, whether an AccessLogValve is active
++ */
++ public boolean isAccessLogEnabled() {
++ return accessLogEnabled;
++ }
++
++ @Before
++ @Override
++ public void setUp() throws Exception {
++ super.setUp();
++
++ // Trigger loading of catalina.properties
++ CatalinaProperties.getProperty("foo");
++
++ File appBase = new File(getTemporaryDirectory(), "webapps");
++ if (!appBase.exists() && !appBase.mkdir()) {
++ fail("Unable to create appBase for test");
++ }
++
++ // A sanity check that the Server reference has been cleared after
++ // the previous test run
++ assertNull("A Server has already been created.",
++ ServerFactory.getServer(false));
++
++ tomcat = new TomcatWithFastSessionIDs();
++
++ String protocol = getProtocol();
++ Connector connector = new Connector(protocol);
++ // Listen only on localhost
++ connector.setAttribute("address",
++ InetAddress.getByName("localhost").getHostAddress());
++ // Use random free port
++ connector.setPort(0);
++ // Mainly set to reduce timeouts during async tests
++ connector.setAttribute("connectionTimeout", "3000");
++ tomcat.getService().addConnector(connector);
++ tomcat.setConnector(connector);
++
++ // Add AprLifecycleListener if we are using the Apr connector
++ if (protocol.contains("Apr")) {
++ StandardServer server = (StandardServer) tomcat.getServer();
++ AprLifecycleListener listener = new AprLifecycleListener();
++ listener.setSSLRandomSeed("/dev/urandom");
++ server.addLifecycleListener(listener);
++ connector.setAttribute("pollerThreadCount", Integer.valueOf(1));
++ }
++
++ File catalinaBase = getTemporaryDirectory();
++ tomcat.setBaseDir(catalinaBase.getAbsolutePath());
++ tomcat.getHost().setAppBase(appBase.getAbsolutePath());
++
++ accessLogEnabled = Boolean.parseBoolean(
++ System.getProperty("tomcat.test.accesslog", "false"));
++ if (accessLogEnabled) {
++ String accessLogDirectory = System
++ .getProperty("tomcat.test.reports");
++ if (accessLogDirectory == null) {
++ accessLogDirectory = new File(getBuildDirectory(), "logs")
++ .toString();
++ }
++ AccessLogValve alv = new AccessLogValve();
++ alv.setDirectory(accessLogDirectory);
++ alv.setPattern("%h %l %u %t \"%r\" %s %b %I %D");
++ tomcat.getHost().getPipeline().addValve(alv);
++ }
++
++ // Cannot delete the whole tempDir, because logs are there,
++ // but delete known subdirectories of it.
++ addDeleteOnTearDown(new File(catalinaBase, "webapps"));
++ addDeleteOnTearDown(new File(catalinaBase, "work"));
++ }
++
++ protected String getProtocol() {
++ // Has a protocol been specified
++ String protocol = System.getProperty("tomcat.test.protocol");
++
++ // Use BIO by default
++ if (protocol == null) {
++ protocol = "org.apache.coyote.http11.Http11Protocol";
++ }
++
++ return protocol;
++ }
++
++ @After
++ @Override
++ public void tearDown() throws Exception {
++ try {
++ if (tomcat.server != null) {
++ tomcat.stop();
++ tomcat.destroy();
++ }
++ } finally {
++ ServerFactory.clear();
++ super.tearDown();
++ }
++ }
++
++ /**
++ * Simple Hello World servlet for use by test cases
++ */
++ public static final class HelloWorldServlet extends HttpServlet {
++
++ private static final long serialVersionUID = 1L;
++
++ public static final String RESPONSE_TEXT =
++ "<html><body><p>Hello World</p></body></html>";
++
++ @Override
++ protected void doGet(HttpServletRequest req, HttpServletResponse resp)
++ throws ServletException, IOException {
++ PrintWriter out = resp.getWriter();
++ out.print(RESPONSE_TEXT);
++ }
++ }
++
++
++ public static final class RequestDescriptor {
++
++ private final Map<String, String> requestInfo =
++ new HashMap<String, String>();
++ private final Map<String, String> contextInitParameters =
++ new HashMap<String, String>();
++ private final Map<String, String> contextAttributes =
++ new HashMap<String, String>();
++ private final Map<String, String> headers =
++ new CaseInsensitiveKeyMap<String>();
++ private final Map<String, String> attributes =
++ new HashMap<String, String>();
++ private final Map<String, String> params =
++ new HashMap<String, String>();
++ private final Map<String, String> sessionAttributes =
++ new HashMap<String, String>();
++
++ public Map<String, String> getRequestInfo() {
++ return requestInfo;
++ }
++
++ public Map<String, String> getContextInitParameters() {
++ return contextInitParameters;
++ }
++
++ public Map<String, String> getContextAttributes() {
++ return contextAttributes;
++ }
++
++ public Map<String, String> getHeaders() {
++ return headers;
++ }
++
++ public Map<String, String> getAttributes() {
++ return attributes;
++ }
++
++ public Map<String, String> getParams() {
++ return params;
++ }
++
++ public Map<String, String> getSessionAttributes() {
++ return sessionAttributes;
++ }
++
++ public String getRequestInfo(String name) {
++ return requestInfo.get(name);
++ }
++
++ public void putRequestInfo(String name, String value) {
++ requestInfo.put(name, value);
++ }
++
++ public String getContextInitParameter(String name) {
++ return contextInitParameters.get(name);
++ }
++
++ public void putContextInitParameter(String name, String value) {
++ contextInitParameters.put(name, value);
++ }
++
++ public String getContextAttribute(String name) {
++ return contextAttributes.get(name);
++ }
++
++ public void putContextAttribute(String name, String value) {
++ contextAttributes.put(name, value);
++ }
++
++ public String getHeader(String name) {
++ return headers.get(name);
++ }
++
++ public void putHeader(String name, String value) {
++ headers.put(name, value);
++ }
++
++ public String getAttribute(String name) {
++ return attributes.get(name);
++ }
++
++ public void putAttribute(String name, String value) {
++ attributes.put(name, value);
[... 1503 lines stripped ...]
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@tomcat.apache.org
For additional commands, e-mail: dev-help@tomcat.apache.org