hazendaz / httpunit / 636

Committed 05 Dec 2025 03:27AM UTC coverage: 80.509%. Remained the same

Build # 636

Build Type

push

github

Committed by

hazendaz

Commit Message

Cleanup more old since tags

you guessed it, at this point going to jautodoc the rest so the warnings on builds go away ;)

Run Details

3213 of 4105 branches covered (78.27%)

Branch coverage included in aggregate %.

8249 of 10132 relevant lines covered (81.42%)

0.81 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

73.13

/src/main/java/com/meterware/servletunit/ServletUnitHttpResponse.java

/*
 * MIT License
 *
 * Copyright 2011-2025 Russell Gold
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
 * documentation files (the "Software"), to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and
 * to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or substantial portions
 * of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
 * THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
 * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */
package com.meterware.servletunit;

import com.meterware.httpunit.HttpUnitUtils;

import jakarta.servlet.ServletOutputStream;
import jakarta.servlet.WriteListener;
import jakarta.servlet.http.Cookie;
import jakarta.servlet.http.HttpServletResponse;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.TimeZone;
import java.util.Vector;

class ServletUnitHttpResponse implements HttpServletResponse {

    // rfc1123-date is "Sun, 06 Nov 1994 08:49:37 GMT"
    private static final String RFC1123_DATE_SPEC = "EEE, dd MMM yyyy HH:mm:ss z";
    private boolean _committed;
    private Locale _locale = Locale.getDefault();

    private static final Hashtable ENCODING_MAP = new Hashtable<>();

    /**
     * Adds the specified cookie to the response. It can be called multiple times to set more than one cookie.
     */
    @Override
    public void addCookie(Cookie cookie) {
        _cookies.addElement(cookie);
    }

    /**
     * Checks whether the response message header has a field with the specified name.
     */
    @Override
    public boolean containsHeader(String name) {
        return _headers.containsKey(name.toUpperCase());
    }

    /**
     * Encodes the specified URL by including the session ID in it, or, if encoding is not needed, returns the URL
     * unchanged. The implementation of this method should include the logic to determine whether the session ID needs
     * to be encoded in the URL. For example, if the browser supports cookies, or session tracking is turned off, URL
     * encoding is unnecessary.
     **/
    @Override
    public String encodeURL(String url) {
        return url;
    }

    /**
     * Encodes the specified URL for use in the <code>sendRedirect</code> method or, if encoding is not needed, returns
     * the URL unchanged. The implementation of this method should include the logic to determine whether the session ID
     * needs to be encoded in the URL. Because the rules for making this determination differ from those used to decide
     * whether to encode a normal link, this method is seperate from the <code>encodeUrl</code> method.
     **/
    @Override
    public String encodeRedirectURL(String url) {
        return url;
    }

    /**
     * Sends a temporary redirect response to the client using the specified redirect location URL. The URL must be
     * absolute (for example, <code><em>https://hostname/path/file.html</em></code>). Relative URLs are not permitted
     * here.
     */
    @Override
    public void sendRedirect(String location) throws IOException {
        setStatus(HttpServletResponse.SC_MOVED_TEMPORARILY);
        setHeader("Location", location);
    }

    /**
     * Sends an error response to the client using the specified status code and descriptive message. If setStatus has
     * previously been called, it is reset to the error status code. The message is sent as the body of an HTML page,
     * which is returned to the user to describe the problem. The page is sent with a default HTML header; the message
     * is enclosed in simple body tags (&lt;body&gt;&lt;/body&gt;).
     **/
    @Override
    public void sendError(int sc) throws IOException {
        sendError(sc, "");
    }

    /**
     * Sends an error response to the client using the specified status code and descriptive message. If setStatus has
     * previously been called, it is reset to the error status code. The message is sent as the body of an HTML page,
     * which is returned to the user to describe the problem. The page is sent with a default HTML header; the message
     * is enclosed in simple body tags (&lt;body&gt;&lt;/body&gt;).
     **/
    @Override
    public void sendError(int sc, String msg) throws IOException {
        setStatus(sc);
        _statusMessage = msg;

        _writer = null;
        _servletStream = null;

        setContentType("text/html");
        getWriter().println("<html><head><title>" + msg + "</title></head><body>" + msg + "</body></html>");
    }

    /**
     * Sets the status code for this response. This method is used to set the return status code when there is no error
     * (for example, for the status codes SC_OK or SC_MOVED_TEMPORARILY). If there is an error, the
     * <code>sendError</code> method should be used instead.
     **/
    @Override
    public void setStatus(int sc) {
        _status = sc;
    }

    /**
     * Adds a field to the response header with the given name and value. If the field had already been set, the new
     * value overwrites the previous one. The <code>containsHeader</code> method can be used to test for the presence of
     * a header before setting its value.
     **/
    @Override
    public void setHeader(String name, String value) {
        ArrayList values = new ArrayList<>();
        values.add(value);
        synchronized (_headers) {
            _headers.put(name.toUpperCase(), values);
        }
    }

    /**
     * Adds a field to the response header with the given name and integer value. If the field had already been set, the
     * new value overwrites the previous one. The <code>containsHeader</code> method can be used to test for the
     * presence of a header before setting its value.
     **/
    @Override
    public void setIntHeader(String name, int value) {
        setHeader(name, asHeaderValue(value));
    }

    /**
     * Adds a field to the response header with the given name and integer value. If the field had already been set, the
     * new value overwrites the previous one. The <code>containsHeader</code> method can be used to test for the
     * presence of a header before setting its value.
     **/
    public void setLongHeader(String name, long value) {
        setHeader(name, asHeaderLongValue(value));
    }

    private String asHeaderValue(int value) {
        return Integer.toString(value);
    }

    private String asHeaderLongValue(long value) {
        return Long.toString(value);
    }

    /**
     * Adds a field to the response header with the given name and date-valued field. The date is specified in terms of
     * milliseconds since the epoch. If the date field had already been set, the new value overwrites the previous one.
     * The <code>containsHeader</code> method can be used to test for the presence of a header before setting its value.
     **/
    @Override
    public void setDateHeader(String name, long date) {
        setHeader(name, asDateHeaderValue(date));
    }

    private String asDateHeaderValue(long date) {
        Date value = new Date(date);
        SimpleDateFormat formatter = new SimpleDateFormat(RFC1123_DATE_SPEC, Locale.US);
        formatter.setTimeZone(TimeZone.getTimeZone("Greenwich Mean Time"));
        return formatter.format(value);
    }

    /**
     * Returns the name of the character set encoding used for the MIME body sent by this response.
     **/
    @Override
    public String getCharacterEncoding() {
        return _encoding == null ? StandardCharsets.ISO_8859_1.name() : _encoding;
    }

    /**
     * Sets the content type of the response the server sends to the client. The content type may include the type of
     * character encoding used, for example, <code>text/html; charset=ISO-8859-4</code>.
     * <p>
     * You can only use this method once, and you should call it before you obtain a <code>PrintWriter</code> or
     * {@link ServletOutputStream} object to return a response.
     **/
    @Override
    public void setContentType(String type) {
        String[] typeAndEncoding = HttpUnitUtils.parseContentTypeHeader(type);

        _contentType = typeAndEncoding[0];
        if (typeAndEncoding[1] != null) {
            _encoding = typeAndEncoding[1];
        }
    }

    /**
     * Returns a {@link ServletOutputStream} suitable for writing binary data in the response. The servlet engine does
     * not encode the binary data.
     *
     * @exception IllegalStateException
     *                if you have already called the <code>getWriter</code> method
     **/
    @Override
    public ServletOutputStream getOutputStream() throws IOException {
        if (_writer != null) {
            throw new IllegalStateException("Tried to create output stream; writer already exists");
        }
        if (_servletStream == null) {
            _outputStream = new ByteArrayOutputStream();
            _servletStream = new ServletUnitOutputStream(_outputStream);
        }
        return _servletStream;
    }

    /**
     * Returns a <code>PrintWriter</code> object that you can use to send character text to the client. The character
     * encoding used is the one specified in the <code>charset=</code> property of the {@link #setContentType} method,
     * which you must call <i>before</i> you call this method.
     * <p>
     * If necessary, the MIME type of the response is modified to reflect the character encoding used.
     * <p>
     * You cannot use this method if you have already called {@link #getOutputStream} for this
     * <code>ServletResponse</code> object.
     *
     * @exception IllegalStateException
     *                if the <code>getOutputStream</code> method has already been called for this response object; in
     *                that case, you can't use this method
     **/
    @Override
    public PrintWriter getWriter() {
        if (_servletStream != null) {
            throw new IllegalStateException("Tried to create writer; output stream already exists");
        }
        if (_writer == null) {
            _outputStream = new ByteArrayOutputStream();
            _writer = new PrintWriter(new OutputStreamWriter(_outputStream, Charset.forName(getCharacterEncoding())));
        }
        return _writer;
    }

    /**
     * Sets the length of the content the server returns to the client. In HTTP servlets, this method sets the HTTP
     * Content-Length header.
     **/
    @Override
    public void setContentLength(int len) {
        setIntHeader("Content-Length", len);
    }

    // ------------------------------- the following methods are new in JSDK 2.2 ----------------------

    /**
     * Adds a response header with the given name and value. This method allows response headers to have multiple
     * values.
     **/
    @Override
    public void addHeader(String name, String value) {
        synchronized (_headers) {
            String key = name.toUpperCase();
            List values = (ArrayList) _headers.get(key);
            if (values == null) {
                values = new ArrayList<>();
                _headers.put(key, values);
            }
            values.add(value);
        }
    }

    /**
     * Adds a response header with the given name and value. This method allows response headers to have multiple
     * values.
     **/
    @Override
    public void addIntHeader(String name, int value) {
        addHeader(name, asHeaderValue(value));
    }

    /**
     * Adds a response header with the given name and value. This method allows response headers to have multiple
     * values.
     **/
    @Override
    public void addDateHeader(String name, long value) {
        addHeader(name, asDateHeaderValue(value));
    }

    /**
     * Sets the preferred buffer size for the body of the response. The servlet container will use a buffer at least as
     * large as the size requested. The actual buffer size used can be found using getBufferSize.
     **/
    @Override
    public void setBufferSize(int size) {
        if (getContents().length != 0) {
            throw new IllegalStateException("May not set buffer size after data is written");
        }
    }

    /**
     * Returns the actual buffer size used for the response. If no buffering is used, this method returns 0.
     **/
    @Override
    public int getBufferSize() {
        return 0;
    }

    /**
     * Returns a boolean indicating if the response has been committed. A committed response has already had its status
     * code and headers written.
     **/
    @Override
    public boolean isCommitted() {
        return _committed;
    }

    /**
     * Forces any content in the buffer to be written to the client. A call to this method automatically commits the
     * response, meaning the status code and headers will be written.
     **/
    @Override
    public void flushBuffer() throws IOException {
        _committed = true;
    }

    /**
     * Clears any data that exists in the buffer as well as the status code and headers. If the response has been
     * committed, this method throws an IllegalStateException.
     **/
    @Override
    public void reset() {
        resetBuffer();
        _headers.clear();
        _headersComplete = false;
        _status = SC_OK;
    }

    /**
     * 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 getWriter(). By default, the response locale is the default locale for
     * the server.
     **/
    @Override
    public void setLocale(Locale locale) {
        _locale = locale;
        if (_encoding == null) {
            for (Iterator it = ENCODING_MAP.entrySet().iterator(); it.hasNext();) {
                Map.Entry entry = (Map.Entry) it.next();
                String locales = (String) entry.getValue();
                if (locales.indexOf(locale.getLanguage()) >= 0 || locales.indexOf(locale.toString()) >= 0) {
                    _encoding = (String) entry.getKey();
                    return;
                }
            }
        }
    }

    /**
     * Returns the locale assigned to the response.
     **/
    @Override
    public Locale getLocale() {
        return _locale;
    }

    // ----------------------------- methods added to ServletResponse in JSDK 2.3 --------------------------------------

    /**
     * Clears the content of the underlying buffer in the response without clearing headers or status code. If the
     * response has been committed, this method throws an IllegalStateException.
     */
    @Override
    public void resetBuffer() {
        if (_committed) {
            throw new IllegalStateException("May not resetBuffer after response is committed");
        }
        _outputStream = null;
        _servletStream = null;
        _writer = null;
    }

    // ---------------------------------------------- package methods --------------------------------------------------

    /**
     * Returns the contents of this response.
     **/
    byte[] getContents() {
        if (_outputStream == null) {
            return new byte[0];
        }
        if (_writer != null) {
            _writer.flush();
        }
        return _outputStream.toByteArray();
    }

    /**
     * Returns the status of this response.
     **/
    @Override
    public int getStatus() {
        return _status;
    }

    /**
     * Returns the message associated with this response's status.
     **/
    String getMessage() {
        return _statusMessage;
    }

    public String[] getHeaderFieldNames() {
        if (!_headersComplete) {
            completeHeaders();
        }
        Vector names = new Vector<>();
        for (Enumeration e = _headers.keys(); e.hasMoreElements();) {
            names.addElement(e.nextElement());
        }
        String[] result = new String[names.size()];
        names.copyInto(result);
        return result;
    }

    /**
     * Returns the headers defined for this response.
     *
     * @param name
     *            - the name of the field to get
     **/
    String getHeaderFieldDirect(String name) {
        ArrayList values;
        synchronized (_headers) {
            values = (ArrayList) _headers.get(name.toUpperCase());
        }

        return values == null ? null : (String) values.get(0);
    }

    /**
     * Returns the headers defined for this response.
     *
     * @param name
     **/
    String getHeaderField(String name) {
        if (!_headersComplete) {
            completeHeaders();
        }
        return getHeaderFieldDirect(name);
    }

    /**
     * Return an array of all the header values associated with the specified header name, or an zero-length array if
     * there are no such header values.
     *
     * @param name
     *            Header name to look up
     */
    public String[] getHeaderFields(String name) {
        if (!_headersComplete) {
            completeHeaders();
        }
        ArrayList values;
        synchronized (_headers) {
            values = (ArrayList) _headers.get(name.toUpperCase());
        }
        if (values == null) {
            return new String[0];
        }
        String[] results = new String[values.size()];
        return (String[]) values.toArray(results);

    }

    // --------------------------------------- methods added to ServletRequest in Servlet API 2.4
    // ----------------------------

    @Override
    public void setCharacterEncoding(String string) {
        _encoding = string;
    }

    /**
     * Returns the content type defined for this response.
     **/
    @Override
    public String getContentType() {
        return _contentType;
    }

    // ------------------------------------------- private members ------------------------------------

    private String _contentType = "text/plain";

    private String _encoding;

    private PrintWriter _writer;

    private ServletOutputStream _servletStream;

    private ByteArrayOutputStream _outputStream;

    private int _status = SC_OK;

    private String _statusMessage = "OK";

    private final Hashtable _headers = new Hashtable<>();

    private boolean _headersComplete;

    private Vector _cookies = new Vector<>();

    private void completeHeaders() {
        if (_headersComplete) {
            return;
        }
        addCookieHeader();
        // BR 3301056 ServletUnit handling Content-Type incorrectly
        if (getHeaderFieldDirect("Content-Type") == null) {
            setHeader("Content-Type", _contentType + "; charset=" + getCharacterEncoding());
        }
        _headersComplete = true;
    }

    private void addCookieHeader() {
        if (_cookies.isEmpty()) {
            return;
        }

        StringBuilder sb = new StringBuilder();
        for (Enumeration e = _cookies.elements(); e.hasMoreElements();) {
            Cookie cookie = (Cookie) e.nextElement();
            sb.append(cookie.getName()).append('=').append(cookie.getValue());
            if (cookie.getPath() != null) {
                sb.append(";path=").append(cookie.getPath());
            }
            if (cookie.getDomain() != null) {
                sb.append(";domain=").append(cookie.getDomain());
            }
            if (e.hasMoreElements()) {
                sb.append(',');
            }
        }
        setHeader("Set-Cookie", sb.toString());
    }

    static {
        ENCODING_MAP.put("ISO-8859-1", "ca da de en es fi fr is it nl no pt sv ");
        ENCODING_MAP.put("ISO-8859-2", "cs hr hu pl ro sh sk sl sq ");
        ENCODING_MAP.put("ISO-8859-4", "et lt lv ");
        ENCODING_MAP.put("ISO-8859-5", "be bg mk ru sr uk ");
        ENCODING_MAP.put("ISO-8859-6", "ar ");
        ENCODING_MAP.put("ISO-8859-7", "el ");
        ENCODING_MAP.put("ISO-8859-8", "iw he ");
        ENCODING_MAP.put("ISO-8859-9", "tr ");

        ENCODING_MAP.put("Shift_JIS", "ja ");
        ENCODING_MAP.put("EUC-KR", "ko ");
        ENCODING_MAP.put("TIS-620", "th ");
        ENCODING_MAP.put("GB2312", "zh ");
        ENCODING_MAP.put("Big5", "zh_TW zh_HK ");
    }

    @Override
    public String getHeader(String name) {
        return (String) _headers.get(name.toUpperCase());
    }

    @Override
    public Collection<String> getHeaders(String name) {
        List values;
        synchronized (_headers) {
            values = (ArrayList) _headers.get(name.toUpperCase());
        }
        if (values == null) {
            return Collections.emptyList();
        }
        return values;
    }

    @Override
    public Collection<String> getHeaderNames() {
        if (!_headersComplete) {
            completeHeaders();
        }
        Vector names = new Vector<>();
        for (Enumeration e = _headers.keys(); e.hasMoreElements();) {
            names.addElement(e.nextElement());
        }
        return names;
    }

    @Override
    public void setContentLengthLong(long len) {
        setLongHeader("Content-Length", len);
    }

    public void sendRedirect(String location, int sc, boolean clearBuffer) throws IOException {
        setStatus(sc);
        setHeader("Location", location);
        if (clearBuffer) {
            resetBuffer();
        }
    }

}

class ServletUnitOutputStream extends ServletOutputStream {

    ServletUnitOutputStream(ByteArrayOutputStream stream) {
        _stream = stream;
    }

    @Override
    public void write(int aByte) throws IOException {
        _stream.write(aByte);
    }

    private ByteArrayOutputStream _stream;

    @Override
    public boolean isReady() {
        return false;
    }

    @Override
    public void setWriteListener(WriteListener writeListener) {
        // Do nothing
    }
}

hazendaz / httpunit / 636

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous