private void doTestMessages (
        Class<? extends HttpUpgradeHandler> upgradeHandlerClass)
        throws Exception {
    UpgradeConnection uc = doUpgrade(upgradeHandlerClass);
    PrintWriter pw = new PrintWriter(uc.getWriter());
    BufferedReader reader = uc.getReader();

    pw.println(MESSAGE);
    pw.flush();

    Thread.sleep(500);

    pw.println(MESSAGE);
    pw.flush();

    uc.shutdownOutput();

    // Note: BufferedReader.readLine() strips new lines
    //       ServletInputStream.readLine() does not strip new lines
    String response = reader.readLine();
    Assert.assertEquals(MESSAGE, response);
    response = reader.readLine();
    Assert.assertEquals(MESSAGE, response);

    uc.shutdownInput();
}
 

/**
 * {@inheritDoc}
 *
 * @since Servlet 3.1
 */
@SuppressWarnings("unchecked")
@Override
public <T extends HttpUpgradeHandler> T upgrade(
        Class<T> httpUpgradeHandlerClass) throws java.io.IOException, ServletException {
    T handler;
    InstanceManager instanceManager = null;
    try {
        // Do not go through the instance manager for internal Tomcat classes since they don't
        // need injection
        if (InternalHttpUpgradeHandler.class.isAssignableFrom(httpUpgradeHandlerClass)) {
            handler = httpUpgradeHandlerClass.getConstructor().newInstance();
        } else {
            instanceManager = getContext().getInstanceManager();
            handler = (T) instanceManager.newInstance(httpUpgradeHandlerClass);
        }
    } catch (InstantiationException | IllegalAccessException | InvocationTargetException |
            NamingException | IllegalArgumentException | NoSuchMethodException |
            SecurityException e) {
        throw new ServletException(e);
    }
    UpgradeToken upgradeToken = new UpgradeToken(handler,
            getContext(), instanceManager);

    coyoteRequest.action(ActionCode.UPGRADE, upgradeToken);

    // Output required by RFC2616. Protocol specific headers should have
    // already been set.
    response.setStatus(HttpServletResponse.SC_SWITCHING_PROTOCOLS);

    return handler;
}
 

@Override
protected Processor createUpgradeProcessor(
        SocketWrapperBase<?> socket,
        UpgradeToken upgradeToken) {
    HttpUpgradeHandler httpUpgradeHandler = upgradeToken.getHttpUpgradeHandler();
    if (httpUpgradeHandler instanceof InternalHttpUpgradeHandler) {
        return new UpgradeProcessorInternal(socket, upgradeToken);
    } else {
        return new UpgradeProcessorExternal(socket, upgradeToken);
    }
}
 

private void doTestCheckClosed(
        Class<? extends HttpUpgradeHandler> upgradeHandlerClass)
                throws Exception {
    UpgradeConnection conn = doUpgrade(upgradeHandlerClass);

    Reader r = conn.getReader();
    int c = r.read();

    Assert.assertEquals(-1, c);
}
 

private void doTestFixedResponse(
        Class<? extends HttpUpgradeHandler> upgradeHandlerClass)
                throws Exception {
    UpgradeConnection conn = doUpgrade(upgradeHandlerClass);

    Reader r = conn.getReader();
    int c = r.read();

    Assert.assertEquals(FixedResponseNonBlocking.FIXED_RESPONSE, c);
}
 

@Override
    public <T extends HttpUpgradeHandler> T upgrade(final Class<T> handlerClass) throws IOException {
        throw new IOException("NYI");
//
//        try {
//            InstanceFactory<T> factory = servletContext.getDeployment().getDeploymentInfo().getClassIntrospecter().createInstanceFactory(handlerClass);
//            final InstanceHandle<T> instance = factory.createInstance();
//            //exchange.upgradeChannel(new ServletUpgradeListener(instance, servletContext.getDeployment(), exchange));
//            return instance.getInstance();
//        } catch (InstantiationException e) {
//            throw new RuntimeException(e);
//        } catch (NoSuchMethodException e) {
//            throw new RuntimeException(e);
//        }
    }
 

/**
 * Upgrade the request.
 *
 * @param <T> the type.
 * @param handlerClass the handler class.
 * @return the upgrade handler.
 * @throws IOException when an I/O error occurs.
 * @throws ServletException when a serious error occurs.
 */
@Override
public <T extends HttpUpgradeHandler> T upgrade(Class<T> handlerClass) throws IOException, ServletException {
    try {
        upgradeHandler = handlerClass.newInstance();
    } catch (InstantiationException | IllegalAccessException ie) {
        throw new ServletException(ie);
    }
    setUpgraded(true);
    return (T) upgradeHandler;
}
 

/**
 * {@inheritDoc}
 *
 * @since Servlet 3.1
 */
@Override
public <T extends HttpUpgradeHandler> T upgrade(
        Class<T> httpUpgradeHandlerClass) throws java.io.IOException, ServletException {
    return request.upgrade(httpUpgradeHandlerClass);
}
 

public UpgradeToken(HttpUpgradeHandler httpUpgradeHandler,
        ContextBind contextBind, InstanceManager instanceManager) {
    this.contextBind = contextBind;
    this.httpUpgradeHandler = httpUpgradeHandler;
    this.instanceManager = instanceManager;
}
 

public final HttpUpgradeHandler getHttpUpgradeHandler() {
    return httpUpgradeHandler;
}
 

@Override
public <T extends HttpUpgradeHandler> T upgrade(
        Class<T> httpUpgradeHandlerClass) throws IOException, ServletException {
    throw new RuntimeException("Not implemented");
}
 

private UpgradeConnection doUpgrade(
        Class<? extends HttpUpgradeHandler> upgradeHandlerClass) throws Exception {
    // Setup Tomcat instance
    Tomcat tomcat = getTomcatInstance();

    // No file system docBase required
    Context ctx = tomcat.addContext("", null);

    UpgradeServlet servlet = new UpgradeServlet(upgradeHandlerClass);
    Tomcat.addServlet(ctx, "servlet", servlet);
    ctx.addServletMappingDecoded("/", "servlet");

    tomcat.start();

    // Use raw socket so the necessary control is available after the HTTP
    // upgrade
    Socket socket =
            SocketFactory.getDefault().createSocket("localhost", getPort());

    socket.setSoTimeout(5000);

    UpgradeConnection uc = new UpgradeConnection(socket);

    uc.getWriter().write("GET / HTTP/1.1" + CRLF);
    uc.getWriter().write("Host: whatever" + CRLF);
    uc.getWriter().write(CRLF);
    uc.getWriter().flush();

    String status = uc.getReader().readLine();

    Assert.assertNotNull(status);
    Assert.assertEquals("101", getStatusCode(status));

    // Skip the remaining response headers
    String line = uc.getReader().readLine();
    while (line != null && line.length() > 0) {
        // Skip
        line = uc.getReader().readLine();
    }

    return uc;
}
 

public UpgradeServlet(Class<? extends HttpUpgradeHandler> upgradeHandlerClass) {
    this.upgradeHandlerClass = upgradeHandlerClass;
}
 

private UpgradeConnection doUpgrade(
        Class<? extends HttpUpgradeHandler> upgradeHandlerClass) throws Exception {
    // Setup Tomcat instance
    Tomcat tomcat = getTomcatInstance();

    // No file system docBase required
    Context ctx = tomcat.addContext("", null);

    UpgradeServlet servlet = new UpgradeServlet(upgradeHandlerClass);
    Tomcat.addServlet(ctx, "servlet", servlet);
    ctx.addServletMappingDecoded("/", "servlet");

    tomcat.start();

    // Use raw socket so the necessary control is available after the HTTP
    // upgrade
    Socket socket =
            SocketFactory.getDefault().createSocket("localhost", getPort());

    socket.setSoTimeout(5000);

    UpgradeConnection uc = new UpgradeConnection(socket);

    uc.getWriter().write("GET / HTTP/1.1" + CRLF);
    uc.getWriter().write("Host: whatever" + CRLF);
    uc.getWriter().write(CRLF);
    uc.getWriter().flush();

    String status = uc.getReader().readLine();

    Assert.assertNotNull(status);
    Assert.assertEquals("101", getStatusCode(status));

    // Skip the remaining response headers
    String line = uc.getReader().readLine();
    while (line != null && line.length() > 0) {
        // Skip
        line = uc.getReader().readLine();
    }

    return uc;
}
 

public UpgradeServlet(Class<? extends HttpUpgradeHandler> upgradeHandlerClass) {
    this.upgradeHandlerClass = upgradeHandlerClass;
}
 

@Override
public <T extends HttpUpgradeHandler> T upgrade(Class<T> handlerClass) throws IOException, ServletException {
	throw new UnsupportedOperationException();
}
 

@Override
public <T extends HttpUpgradeHandler> T upgrade(Class<T> handlerClass) throws IOException, ServletException {
	throw new UnsupportedOperationException();
}
 

@Override
public <T extends HttpUpgradeHandler> T upgrade(Class<T> handlerClass) throws IOException, ServletException {
    return null;
}
 

@Override
public <T extends HttpUpgradeHandler> T upgrade(Class<T> handlerClass) throws IOException, ServletException {
    return null;
}
 

@Override
public <T extends HttpUpgradeHandler> T upgrade(Class<T> handlerClass) throws IOException, ServletException {
	throw new UnsupportedOperationException();
}
 

@Override
public <T extends HttpUpgradeHandler> T upgrade(Class<T> handlerClass) throws IOException, ServletException {
	throw new UnsupportedOperationException();
}
 

@Override
public <T extends HttpUpgradeHandler> T upgrade(Class<T> handlerClass) throws IOException, ServletException {
	return null;
}
 

@Override
public <T extends HttpUpgradeHandler> T upgrade(Class<T> arg0) throws IOException, ServletException {
	// TODO Auto-generated method stub
	return null;
}
 

@Override
public <T extends HttpUpgradeHandler> T upgrade(Class<T> handlerClass) throws IOException, ServletException {
    return null;
}
 

@Override
public <T extends HttpUpgradeHandler> T upgrade(Class<T> arg0)
    throws IOException, ServletException {
  return null;
}
 

@Override
public <T extends HttpUpgradeHandler> T upgrade(Class<T> handlerClass) throws IOException, ServletException {
    throw new IllegalStateException("Not supported");
}
 

@Override
public <T extends HttpUpgradeHandler> T upgrade(Class<T> arg0) throws IOException, ServletException {
    return null;
}
 

@Override
public <T extends HttpUpgradeHandler> T upgrade(Class<T> handlerClass) throws IOException, ServletException {
  throw new Error("not supported method");
}
 

@Override
public <T extends HttpUpgradeHandler> T upgrade(final Class<T> aClass) {
    return null;
}
 

@Override
public <T extends HttpUpgradeHandler> T upgrade(Class<T> handlerClass) throws IOException, ServletException {
  return d.upgrade(handlerClass);
}