mockhttpservletrequest.java

struts+spring 源码 希望能给大家带来帮助

		}
	}

	public void removeAttribute(String name) {
		Assert.notNull(name, "Attribute name must not be null");
		this.attributes.remove(name);
	}

	/**
	 * Add a new preferred locale, before any existing locales.
	 */
	public void addPreferredLocale(Locale locale) {
		Assert.notNull(locale, "Locale must not be null");
		this.locales.add(0, locale);
	}

	public Locale getLocale() {
		return (Locale) this.locales.get(0);
	}

	public Enumeration getLocales() {
		return this.locales.elements();
	}

	public void setSecure(boolean secure) {
		this.secure = secure;
	}

	public boolean isSecure() {
		return secure;
	}

	public RequestDispatcher getRequestDispatcher(String path) {
		return new MockRequestDispatcher(path);
	}

	public String getRealPath(String path) {
		return this.servletContext.getRealPath(path);
	}

	public void setRemotePort(int remotePort) {
		this.remotePort = remotePort;
	}

	public int getRemotePort() {
		return remotePort;
	}

	public void setLocalName(String localName) {
		this.localName = localName;
	}

	public String getLocalName() {
		return localName;
	}

	public void setLocalAddr(String localAddr) {
		this.localAddr = localAddr;
	}

	public String getLocalAddr() {
		return localAddr;
	}

	public void setLocalPort(int localPort) {
		this.localPort = localPort;
	}

	public int getLocalPort() {
		return localPort;
	}


	//---------------------------------------------------------------------
	// HttpServletRequest interface
	//---------------------------------------------------------------------

	public void setAuthType(String authType) {
		this.authType = authType;
	}

	public String getAuthType() {
		return authType;
	}

	public void setCookies(Cookie[] cookies) {
		this.cookies = cookies;
	}

	public Cookie[] getCookies() {
		return cookies;
	}

	/**
	 * Add a header entry for the given name.
	 * <p>If there was no entry for that header name before,
	 * the value will be used as-is. In case of an existing entry,
	 * a String array will be created, adding the given value (more
	 * specifically, its toString representation) as further element.
	 * <p>Multiple values can only be stored as list of Strings,
	 * following the Servlet spec (see <code>getHeaders</code> accessor).
	 * As alternative to repeated <code>addHeader</code> calls for
	 * individual elements, you can use a single call with an entire
	 * array or Collection of values as parameter.
	 * @see #getHeaderNames
	 * @see #getHeader
	 * @see #getHeaders
	 * @see #getDateHeader
	 * @see #getIntHeader
	 */
	public void addHeader(String name, Object value) {
		Assert.notNull(name, "Header name must not be null");
		Assert.notNull(value, "Header value must not be null");
		HttpHeader header = (HttpHeader) this.headers.get(name.toLowerCase());
		if (header == null) {
			header = new HttpHeader(name);
			this.headers.put(name.toLowerCase(), header);
		}
		if (value instanceof Collection) {
			header.addValues((Collection) value);
		}
		else if (value.getClass().isArray()) {
			header.addValues((Object[]) value);
		}
		else {
			header.addValue(value);
		}
	}

	public long getDateHeader(String name) {
		Assert.notNull(name, "Header name must not be null");
		HttpHeader header = (HttpHeader) this.headers.get(name.toLowerCase());
		Object value = (header == null) ? null : header.getValue();
		if (value instanceof Date) {
			return ((Date) value).getTime();
		}
		else if (value instanceof Number) {
			return ((Number) value).longValue();
		}
		else if (value != null) {
			throw new IllegalArgumentException(
					"Value for header '" + name + "' is neither a Date nor a Number: " + value);
		}
		else {
			return -1L;
		}
	}

	public String getHeader(String name) {
		HttpHeader header = (HttpHeader) this.headers.get(name.toLowerCase());
		return header == null ? null : header.getValue().toString();
	}

	public Enumeration getHeaders(String name) {
		HttpHeader header = (HttpHeader) this.headers.get(name.toLowerCase());
		return Collections.enumeration(
				(header == null) ? Collections.EMPTY_LIST : header.getValues());
	}

	public Enumeration getHeaderNames() {
		return new HttpHeaderNamesEnumerator(this.headers.values());
	}

	public int getIntHeader(String name) {
		Assert.notNull(name, "Header name must not be null");
		HttpHeader header = (HttpHeader)this.headers.get(name.toLowerCase());
        Object value = (header == null) ? null : header.getValue();
		if (value instanceof Number) {
			return ((Number) value).intValue();
		}
		else if (value instanceof String) {
			return Integer.parseInt((String) value);
		}
		else if (value != null) {
			throw new NumberFormatException("Value for header '" + name + "' is not a Number : " + value);
		}
		else {
			return -1;
		}
	}

	public void setMethod(String method) {
		this.method = method;
	}

	public String getMethod() {
		return method;
	}

	public void setPathInfo(String pathInfo) {
		this.pathInfo = pathInfo;
	}

	public String getPathInfo() {
		return pathInfo;
	}

	public String getPathTranslated() {
		return (this.pathInfo != null ? getRealPath(this.pathInfo) : null);
	}

	public void setContextPath(String contextPath) {
		this.contextPath = contextPath;
	}

	public String getContextPath() {
		return contextPath;
	}

	public void setQueryString(String queryString) {
		this.queryString = queryString;
	}

	public String getQueryString() {
		return queryString;
	}

	public void setRemoteUser(String remoteUser) {
		this.remoteUser = remoteUser;
	}

	public String getRemoteUser() {
		return remoteUser;
	}

	/**
	 * @deprecated in favor of addUserRole
	 * @see #addUserRole
	 */
	public void addRole(String role) {
		addUserRole(role);
	}

	public void addUserRole(String role) {
		this.userRoles.add(role);
	}

	public boolean isUserInRole(String role) {
		return this.userRoles.contains(role);
	}

	public void setUserPrincipal(Principal userPrincipal) {
		this.userPrincipal = userPrincipal;
	}

	public Principal getUserPrincipal() {
		return userPrincipal;
	}

	public String getRequestedSessionId() {
		HttpSession session = this.getSession();
		return (session != null ? session.getId() : null);
	}

	public void setRequestURI(String requestURI) {
		this.requestURI = requestURI;
	}

	public String getRequestURI() {
		return requestURI;
	}

	public StringBuffer getRequestURL() {
		StringBuffer url = new StringBuffer(this.scheme);
		url.append("://").append(this.serverName).append(':').append(this.serverPort);
		url.append(getRequestURI());
		return url;
	}

	public void setServletPath(String servletPath) {
		this.servletPath = servletPath;
	}

	public String getServletPath() {
		return servletPath;
	}

	public void setSession(HttpSession session) {
		this.session = session;
		if (session instanceof MockHttpSession) {
			MockHttpSession mockSession = ((MockHttpSession) session);
			mockSession.access();
		}
	}

	public HttpSession getSession(boolean create) {
		// reset session if invalidated
		if (this.session instanceof MockHttpSession && ((MockHttpSession) this.session).isInvalid()) {
			this.session = null;
		}
		// create new session if necessary
		if (this.session == null && create) {
			this.session = new MockHttpSession(this.servletContext);
		}
		return this.session;
	}

	public HttpSession getSession() {
		return getSession(true);
	}

	public void setRequestedSessionIdValid(boolean requestedSessionIdValid) {
		this.requestedSessionIdValid = requestedSessionIdValid;
	}

	public boolean isRequestedSessionIdValid() {
		return this.requestedSessionIdValid;
	}

	public void setRequestedSessionIdFromCookie(boolean requestedSessionIdFromCookie) {
		this.requestedSessionIdFromCookie = requestedSessionIdFromCookie;
	}

	public boolean isRequestedSessionIdFromCookie() {
		return this.requestedSessionIdFromCookie;
	}

	public void setRequestedSessionIdFromURL(boolean requestedSessionIdFromURL) {
		this.requestedSessionIdFromURL = requestedSessionIdFromURL;
	}

	public boolean isRequestedSessionIdFromURL() {
		return this.requestedSessionIdFromURL;
	}

	public boolean isRequestedSessionIdFromUrl() {
		return isRequestedSessionIdFromURL();
	}


	private static final class HttpHeader {

		private String name;
		private List values = new LinkedList();


		HttpHeader(String name) {
			Assert.notNull(name, "The header name cannot be null.");
			this.name = name;
		}


		void addValue(Object value) {
			Assert.notNull(values, "Value must not be null.");
			this.values.add(value);
		}

		void addValues(Collection values) {
			Assert.notNull(values, "Values collection must not be null.");
			for (Iterator it = values.iterator(); it.hasNext();) {
				Object element = it.next();
				Assert.notNull(element, "Value collection must not contain null elements.");
				this.values.add(element);
			}
		}

		void addValues(Object[] values) {
			this.values.addAll(Arrays.asList(values));
		}

		String getName() {
			return this.name;
		}

		List getValues() {
			return this.values;
		}

		Object getValue() {
			return this.values.isEmpty() ? null : this.values.get(0);
		}

	}


	private static final class HttpHeaderNamesEnumerator implements Enumeration {

		private Iterator httpHeaderIterator;


		HttpHeaderNamesEnumerator(Collection headers) {
			Assert.notNull("Headers must not be null.");
			this.httpHeaderIterator = headers.iterator();
		}


		public boolean hasMoreElements() {
			return this.httpHeaderIterator.hasNext();
		}

		public Object nextElement() {
			return ((HttpHeader) this.httpHeaderIterator.next()).getName();
		}

	}

}