Calling flush() on the ServletOutputStream commits the response.
* Either this method or {@link #getWriter} may
* be called to write the body, not both.
*
* @return a {@link ServletOutputStream} for writing binary data
*
* @exception IllegalStateException if the getWriter method
* has been called on this response
*
* @exception IOException if an input or output exception occurred
*
* @see #getWriter
*
*/
public ServletOutputStream getOutputStream() throws IOException
{
if( this.calledGetWriter )
throw new IllegalStateException( "The getWriter method has already been called" );
ServletOutputStream oStream = null;
if( null == this.servOStream )
oStream = new ServletOutputStreamSimulator();
else
oStream = new ServletOutputStreamSimulator( this.servOStream );
// resets the status of servOStream to prevent us from possible using a closed stream
this.servOStream = null;
this.calledGetOutputStream = true;
return oStream;
}
/**
* Returns a PrintWriter object that
* can send character text to the client.
* The character encoding used is the one specified
* in the charset= property of the
* {@link #setContentType} method, which must be called
* before calling this method for the charset to take effect.
*
*
If necessary, the MIME type of the response is * modified to reflect the character encoding used. * *
Calling flush() on the PrintWriter commits the response. * *
Either this method or {@link #getOutputStream} may be called
* to write the body, not both.
*
*
* @return a PrintWriter object that
* can return character data to the client
*
* @exception UnsupportedEncodingException if the charset specified in
* setContentType cannot be
* used
*
* @exception IllegalStateException if the getOutputStream
* method has already been called for this
* response object
*
* @exception IOException if an input or output exception occurred
*
* @see #getOutputStream
* @see #setContentType
*
*/
public PrintWriter getWriter() throws IOException
{
if( this.calledGetOutputStream )
throw new IllegalStateException( "The getOutputStream method has already been called" );
if( stringWriter == null )
stringWriter = new StringWriter();
if( printWriter == null )
printWriter = new PrintWriter( stringWriter );
this.calledGetWriter = true;
return printWriter;
}
/**
* Use this method to pick up the string buffer which will hold
* the contents of the string buffer. You can then
* write your test case to examine the contents of this
* buffer and match it against an expected output.
*/
public StringBuffer getWriterBuffer()
{
if (stringWriter==null) return null;
return stringWriter.getBuffer();
}
//TODO: better documentation
public boolean isCommitted()
{
return isCommitted;
}
public void setIsCommitted(boolean isCommitted) {
this.isCommitted = isCommitted;
}
/**
* Reinitializes all local variables.
* Note, in most servlet containers, you may get an
* IllegalStateException if you call this method
* after committing the response.
* That behavior is not replicated here.
*/
public void reset()
{
this.calledGetOutputStream = false;
this.calledGetWriter = false;
this.contentLength = 0;
this.contentType = null;
this.stringWriter = null;
this.printWriter = null;
headers = new HashMap();
}
/**
* This method is not supported.
*/
public void resetBuffer()
{
throw new UnsupportedOperationException("resetBuffer operation is not supported.");
}
/**
* Sends an error response to the client using the specified
* status clearing the buffer. This method always throws
* an AssertionFailedError with the corresponding error
* number.
*
* @param sc the error status code
*/
public void sendError(int sc) throws IOException
{
setStatus(sc);
throw new AssertionFailedError("received error: " + sc);
}
/**
* Sends an error response to the client using the specified
* status clearing the buffer. This method always throws
* an AssertionFailedError with the corresponding error
* number and descriptive text.
*
* @param sc the error status code
* @param msg the descriptive message
*/
public void sendError(int sc, String msg) throws IOException
{
setStatus(sc,msg);
throw new AssertionFailedError("received error " + sc + " : " + msg);
}
/**
* Resets the response and sets the appropriate redirect headers.
*/
public void sendRedirect(String location) throws IOException
{
reset();
setStatus(SC_MOVED_TEMPORARILY);
setHeader("Location", location);
}
/**
* This method is not supported.
*/
public void setBufferSize(int size)
{
throw new UnsupportedOperationException("setBufferSize operation not supported.");
}
/**
* Sets the length of the content body in the response
* In HTTP servlets, this method sets the HTTP Content-Length header.
*
*
* @param len an integer specifying the length of the
* content being returned to the client; sets
* the Content-Length header
*
*/
public void setContentLength(int len)
{
this.contentLength = len;
}
/**
* returns the content length previously set in setContentLength()
* @return the content length
*/
public int getContentLength(){
return this.contentLength;
}
/**
* Sets the content type of the response being sent to
* the client. The content type may include the type of character
* encoding used, for example, text/html; charset=ISO-8859-4.
*
*
If obtaining a PrintWriter, this method should be
* called first.
*
*
* @param type a String specifying the MIME
* type of the content
*
* @see #getOutputStream
* @see #getWriter
*
*/
public void setContentType(String type)
{
this.contentType = type;
}
/**
* returns the content type previously set in setContentType()
* @return the content type
*/
public String getContentType(){
return this.contentType;
}
/**
* This method is not supported.
*/
public void setDateHeader(String name, long date)
{
this.addDateHeader(name,date);
}
/**
* adds the name/value pair to the headers
*/
public void setHeader(String name, String value)
{
if (name.equalsIgnoreCase("content-type")) {
setContentType(value);
return;
}
else if (name.equalsIgnoreCase("content-length")) {
this.setContentLength(Integer.parseInt(value));
return;
}
headers.put(name, value);
}
/**
* Removes a given header
*/
public void removeHeader(String name) {
if (headers.containsKey(name))
headers.remove(name);
}
/**
* Adds the given name/value pair to the headers collection.
*/
public void setIntHeader(String name, int value)
{
setHeader(name, String.valueOf(value));
}
/**
* Sets the locale of the response, setting the headers (including the
* Content-Type's charset) as appropriate. This method should be called
* before a call to {@link #getWriter}. By default, the response locale
* is the default locale for the server.
*
* @param loc the locale of the response
*
* @see #getLocale
*
*/
public void setLocale(Locale loc)
{
this.locale = loc;
}
/**
* The default action of calling the getOutputStream method
* is to return a javax.servlet.ServletOutputStream object
* that sends the data to System.out. If you don't want
* the output sent to System.out you can use this method to
* set where the output will go. Please note, subsequent calls to
* getOutputStream will reset the output path to
* System.out. This prevents the OutputStream returned by
* calling getOutputStream from writing to a closed stream
*
* @param out The java.io.OutputStream that represents
* the real path of the output.
*/
public void setOutputStream( OutputStream out )
{
this.servOStream = out;
}
/**
* Sets the given status code.
*/
public void setStatus(int sc)
{
setStatus(sc, null);
}
/**
* Sets the given status and an associated message.
*/
public void setStatus(int sc, String sm)
{
this.status = sc;
this.message = sm;
}
/**
* Returns the status code for this response, which is useful for testing expected errors.
* @return the status code for this response.
*/
public int getStatusCode() {
return this.status;
}
public void setCharacterEncoding(String charEncoding) {
this.charEncoding = charEncoding;
}
public String getMessage() {
return message;
}
}