Juergen Hoeller
11 years ago
34 changed files with 77 additions and 1649 deletions
@ -1,246 +0,0 @@
@@ -1,246 +0,0 @@
|
||||
/* |
||||
* Copyright 2002-2014 the original author or authors. |
||||
* |
||||
* Licensed 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.springframework.test; |
||||
|
||||
import org.springframework.util.Assert; |
||||
|
||||
/** |
||||
* {@code AssertThrows} is a simple method object that encapsulates the |
||||
* <em>'test-for-exception'</em> scenario for unit testing. Intended for |
||||
* use with JUnit or TestNG. |
||||
* |
||||
* <p>Given the following business class... |
||||
* |
||||
* <pre class="code"> |
||||
* // the class under test
|
||||
* public class Foo { |
||||
* public void someBusinessLogic(String name) { |
||||
* if (name == null) { |
||||
* throw new IllegalArgumentException("The 'name' argument is required"); |
||||
* } |
||||
* // rest of business logic here...
|
||||
* } |
||||
* }</pre> |
||||
* |
||||
* <p>The test for the above bad argument path can be expressed using |
||||
* {@code AssertThrows} like so: |
||||
* |
||||
* <pre class="code"> |
||||
* public class FooTest { |
||||
* public void testSomeBusinessLogicBadArgumentPath() { |
||||
* new AssertThrows(IllegalArgumentException.class) { |
||||
* public void test() { |
||||
* new Foo().someBusinessLogic(null); |
||||
* } |
||||
* }.runTest(); |
||||
* } |
||||
* }</pre> |
||||
* |
||||
* <p>This will result in the test passing if the {@code Foo.someBusinessLogic(..)} |
||||
* method threw an {@code IllegalArgumentException}; if it did not, the |
||||
* test would fail with the following message: |
||||
* |
||||
* <pre class="code">"Must have thrown a [class java.lang.IllegalArgumentException]"</pre> |
||||
* |
||||
* <p>If the <strong>wrong</strong> type of {@code Throwable} was thrown, |
||||
* the test will also fail, this time with a message similar to the following: |
||||
* |
||||
* <pre class="code">"java.lang.AssertionError: Was expecting a [class java.lang.UnsupportedOperationException] to be thrown, but instead a [class java.lang.IllegalArgumentException] was thrown"</pre> |
||||
* |
||||
* <p>The test for the correct {@code Throwable} respects polymorphism, |
||||
* so you can test that any old {@code Exception} is thrown like so: |
||||
* |
||||
* <pre class="code"> |
||||
* public class FooTest { |
||||
* public void testSomeBusinessLogicBadArgumentPath() { |
||||
* // any Exception will do...
|
||||
* new AssertThrows(Exception.class) { |
||||
* public void test() { |
||||
* new Foo().someBusinessLogic(null); |
||||
* } |
||||
* }.runTest(); |
||||
* } |
||||
* }</pre> |
||||
* |
||||
* @author Rick Evans |
||||
* @author Juergen Hoeller |
||||
* @author Sam Brannen |
||||
* @since 2.0 |
||||
* @deprecated Favor use of JUnit's {@code @Test(expected=...)} or |
||||
* {@code @Rule ExpectedException} support or TestNG's |
||||
* {@code @Test(expectedExceptions=...)} support |
||||
*/ |
||||
@Deprecated |
||||
public abstract class AssertThrows { |
||||
|
||||
private final Class<? extends Throwable> expectedException; |
||||
|
||||
private String failureMessage; |
||||
|
||||
private Throwable actualException; |
||||
|
||||
|
||||
/** |
||||
* Create a new instance of the {@code AssertThrows} class. |
||||
* @param expectedException the {@link Throwable} expected to be |
||||
* thrown during the execution of the surrounding test |
||||
* @throws IllegalArgumentException if the supplied {@code expectedException} is |
||||
* {@code null}; or if said argument is not a {@code Throwable}-derived class
|
||||
*/ |
||||
public AssertThrows(Class<? extends Throwable> expectedException) { |
||||
this(expectedException, null); |
||||
} |
||||
|
||||
/** |
||||
* Create a new instance of the {@code AssertThrows} class. |
||||
* @param expectedException the {@link Throwable} expected to be |
||||
* thrown during the execution of the surrounding test |
||||
* @param failureMessage the extra, contextual failure message that will be |
||||
* included in the failure text if the text fails (can be {@code null}) |
||||
* @throws IllegalArgumentException if the supplied {@code expectedException} is |
||||
* {@code null}; or if said argument is not a {@code Throwable}-derived class
|
||||
*/ |
||||
public AssertThrows(Class<? extends Throwable> expectedException, String failureMessage) { |
||||
Assert.notNull(expectedException, "expectedException is required"); |
||||
Assert.isAssignable(Throwable.class, expectedException, "expectedException: "); |
||||
this.expectedException = expectedException; |
||||
this.failureMessage = failureMessage; |
||||
} |
||||
|
||||
/** |
||||
* Return the {@link java.lang.Throwable} expected to be thrown during |
||||
* the execution of the surrounding test. |
||||
*/ |
||||
protected Class<? extends Throwable> getExpectedException() { |
||||
return this.expectedException; |
||||
} |
||||
|
||||
/** |
||||
* Set the extra, contextual failure message that will be included |
||||
* in the failure text if the text fails. |
||||
*/ |
||||
public void setFailureMessage(String failureMessage) { |
||||
this.failureMessage = failureMessage; |
||||
} |
||||
|
||||
/** |
||||
* Return the extra, contextual failure message that will be included |
||||
* in the failure text if the text fails. |
||||
*/ |
||||
protected String getFailureMessage() { |
||||
return this.failureMessage; |
||||
} |
||||
|
||||
/** |
||||
* Subclass must override this {@code abstract} method and |
||||
* provide the test logic. |
||||
* @throws Throwable if an error occurs during the execution of the |
||||
* aforementioned test logic |
||||
*/ |
||||
public abstract void test() throws Throwable; |
||||
|
||||
/** |
||||
* The main template method that drives the running of the |
||||
* {@linkplain #test() test logic} and the |
||||
* {@linkplain #checkExceptionExpectations(Throwable) checking} of the |
||||
* resulting (expected) {@link java.lang.Throwable}. |
||||
* @see #test() |
||||
* @see #doFail() |
||||
* @see #checkExceptionExpectations(Throwable) |
||||
*/ |
||||
public void runTest() { |
||||
try { |
||||
test(); |
||||
doFail(); |
||||
} |
||||
catch (Throwable actualException) { |
||||
this.actualException = actualException; |
||||
checkExceptionExpectations(actualException); |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* Template method called when the test fails; i.e. the expected |
||||
* {@link java.lang.Throwable} is <b>not</b> thrown. |
||||
* <p>The default implementation simply fails the test by throwing an |
||||
* {@link AssertionError}. |
||||
* <p>If you want to customize the failure message, consider overriding |
||||
* {@link #createMessageForNoExceptionThrown()}, and / or supplying an |
||||
* extra, contextual failure message via the appropriate constructor. |
||||
* @see #getFailureMessage() |
||||
* @see #createMessageForNoExceptionThrown() |
||||
*/ |
||||
protected void doFail() { |
||||
throw new AssertionError(createMessageForNoExceptionThrown()); |
||||
} |
||||
|
||||
/** |
||||
* Creates the failure message used if the test fails |
||||
* (i.e. the expected exception is not thrown in the body of the test). |
||||
* @return the failure message used if the test fails |
||||
* @see #getFailureMessage() |
||||
*/ |
||||
protected String createMessageForNoExceptionThrown() { |
||||
StringBuilder sb = new StringBuilder(); |
||||
sb.append("Should have thrown a [").append(this.getExpectedException()).append("]"); |
||||
if (getFailureMessage() != null) { |
||||
sb.append(": ").append(getFailureMessage()); |
||||
} |
||||
return sb.toString(); |
||||
} |
||||
|
||||
/** |
||||
* Does the donkey work of checking (verifying) that the |
||||
* {@link Throwable} that was thrown in the body of the test is |
||||
* an instance of the {@link #getExpectedException()} class (or an |
||||
* instance of a subclass). |
||||
* <p>If you want to customize the failure message, consider overriding |
||||
* {@link #createMessageForWrongThrownExceptionType(Throwable)}. |
||||
* @param actualException the {@link Throwable} that has been thrown |
||||
* in the body of a test method (will never be {@code null}) |
||||
*/ |
||||
protected void checkExceptionExpectations(Throwable actualException) { |
||||
if (!getExpectedException().isAssignableFrom(actualException.getClass())) { |
||||
AssertionError error = new AssertionError(createMessageForWrongThrownExceptionType(actualException)); |
||||
error.initCause(actualException); |
||||
throw error; |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* Creates the failure message used if the wrong type |
||||
* of {@link java.lang.Throwable} is thrown in the body of the test. |
||||
* @param actualException the actual exception thrown |
||||
* @return the message for the given exception |
||||
*/ |
||||
protected String createMessageForWrongThrownExceptionType(Throwable actualException) { |
||||
StringBuilder sb = new StringBuilder(); |
||||
sb.append("Was expecting a [").append(getExpectedException().getName()); |
||||
sb.append("] to be thrown, but instead a [").append(actualException.getClass().getName()); |
||||
sb.append("] was thrown."); |
||||
return sb.toString(); |
||||
} |
||||
|
||||
/** |
||||
* Expose the actual exception thrown from {@link #test}, if any. |
||||
* @return the actual exception, or {@code null} if none |
||||
*/ |
||||
public final Throwable getActualException() { |
||||
return this.actualException; |
||||
} |
||||
|
||||
} |
||||
@ -1,162 +0,0 @@
@@ -1,162 +0,0 @@
|
||||
/* |
||||
* Copyright 2002-2012 the original author or authors. |
||||
* |
||||
* Licensed 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.springframework.web.context.support; |
||||
|
||||
import java.util.Properties; |
||||
import javax.servlet.ServletContext; |
||||
|
||||
import org.springframework.beans.factory.config.PropertyPlaceholderConfigurer; |
||||
import org.springframework.web.context.ServletContextAware; |
||||
|
||||
/** |
||||
* Subclass of {@link PropertyPlaceholderConfigurer} that resolves placeholders as |
||||
* ServletContext init parameters (that is, {@code web.xml} context-param |
||||
* entries). |
||||
* |
||||
* <p>Can be combined with "locations" and/or "properties" values in addition |
||||
* to web.xml context-params. Alternatively, can be defined without local |
||||
* properties, to resolve all placeholders as {@code web.xml} context-params |
||||
* (or JVM system properties). |
||||
* |
||||
* <p>If a placeholder could not be resolved against the provided local |
||||
* properties within the application, this configurer will fall back to |
||||
* ServletContext parameters. Can also be configured to let ServletContext |
||||
* init parameters override local properties (contextOverride=true). |
||||
* |
||||
* <p>Optionally supports searching for ServletContext <i>attributes</i>: If turned |
||||
* on, an otherwise unresolvable placeholder will matched against the corresponding |
||||
* ServletContext attribute, using its stringified value if found. This can be |
||||
* used to feed dynamic values into Spring's placeholder resolution. |
||||
* |
||||
* <p>If not running within a WebApplicationContext (or any other context that |
||||
* is able to satisfy the ServletContextAware callback), this class will behave |
||||
* like the default PropertyPlaceholderConfigurer. This allows for keeping |
||||
* ServletContextPropertyPlaceholderConfigurer definitions in test suites. |
||||
* |
||||
* @author Juergen Hoeller |
||||
* @since 1.1.4 |
||||
* @see #setLocations |
||||
* @see #setProperties |
||||
* @see #setSystemPropertiesModeName |
||||
* @see #setContextOverride |
||||
* @see #setSearchContextAttributes |
||||
* @see javax.servlet.ServletContext#getInitParameter(String) |
||||
* @see javax.servlet.ServletContext#getAttribute(String) |
||||
* @deprecated in Spring 3.1 in favor of {@link org.springframework.context.support.PropertySourcesPlaceholderConfigurer} |
||||
* in conjunction with {@link StandardServletEnvironment}. |
||||
*/ |
||||
@Deprecated |
||||
public class ServletContextPropertyPlaceholderConfigurer extends PropertyPlaceholderConfigurer |
||||
implements ServletContextAware { |
||||
|
||||
private boolean contextOverride = false; |
||||
|
||||
private boolean searchContextAttributes = false; |
||||
|
||||
private ServletContext servletContext; |
||||
|
||||
|
||||
/** |
||||
* Set whether ServletContext init parameters (and optionally also ServletContext |
||||
* attributes) should override local properties within the application. |
||||
* Default is "false": ServletContext settings serve as fallback. |
||||
* <p>Note that system properties will still override ServletContext settings, |
||||
* if the system properties mode is set to "SYSTEM_PROPERTIES_MODE_OVERRIDE". |
||||
* @see #setSearchContextAttributes |
||||
* @see #setSystemPropertiesModeName |
||||
* @see #SYSTEM_PROPERTIES_MODE_OVERRIDE |
||||
*/ |
||||
public void setContextOverride(boolean contextOverride) { |
||||
this.contextOverride = contextOverride; |
||||
} |
||||
|
||||
/** |
||||
* Set whether to search for matching a ServletContext attribute before |
||||
* checking a ServletContext init parameter. Default is "false": only |
||||
* checking init parameters. |
||||
* <p>If turned on, the configurer will look for a ServletContext attribute with |
||||
* the same name as the placeholder, and use its stringified value if found. |
||||
* Exposure of such ServletContext attributes can be used to dynamically override |
||||
* init parameters defined in {@code web.xml}, for example in a custom |
||||
* context listener. |
||||
* @see javax.servlet.ServletContext#getInitParameter(String) |
||||
* @see javax.servlet.ServletContext#getAttribute(String) |
||||
*/ |
||||
public void setSearchContextAttributes(boolean searchContextAttributes) { |
||||
this.searchContextAttributes = searchContextAttributes; |
||||
} |
||||
|
||||
/** |
||||
* Set the ServletContext to resolve placeholders against. |
||||
* Will be auto-populated when running in a WebApplicationContext. |
||||
* <p>If not set, this configurer will simply not resolve placeholders |
||||
* against the ServletContext: It will effectively behave like a plain |
||||
* PropertyPlaceholderConfigurer in such a scenario. |
||||
*/ |
||||
@Override |
||||
public void setServletContext(ServletContext servletContext) { |
||||
this.servletContext = servletContext; |
||||
} |
||||
|
||||
|
||||
@Override |
||||
protected String resolvePlaceholder(String placeholder, Properties props) { |
||||
String value = null; |
||||
if (this.contextOverride && this.servletContext != null) { |
||||
value = resolvePlaceholder(placeholder, this.servletContext, this.searchContextAttributes); |
||||
} |
||||
if (value == null) { |
||||
value = super.resolvePlaceholder(placeholder, props); |
||||
} |
||||
if (value == null && this.servletContext != null) { |
||||
value = resolvePlaceholder(placeholder, this.servletContext, this.searchContextAttributes); |
||||
} |
||||
return value; |
||||
} |
||||
|
||||
/** |
||||
* Resolves the given placeholder using the init parameters |
||||
* and optionally also the attributes of the given ServletContext. |
||||
* <p>Default implementation checks ServletContext attributes before |
||||
* init parameters. Can be overridden to customize this behavior, |
||||
* potentially also applying specific naming patterns for parameters |
||||
* and/or attributes (instead of using the exact placeholder name). |
||||
* @param placeholder the placeholder to resolve |
||||
* @param servletContext the ServletContext to check |
||||
* @param searchContextAttributes whether to search for a matching |
||||
* ServletContext attribute |
||||
* @return the resolved value, of null if none |
||||
* @see javax.servlet.ServletContext#getInitParameter(String) |
||||
* @see javax.servlet.ServletContext#getAttribute(String) |
||||
*/ |
||||
protected String resolvePlaceholder( |
||||
String placeholder, ServletContext servletContext, boolean searchContextAttributes) { |
||||
|
||||
String value = null; |
||||
if (searchContextAttributes) { |
||||
Object attrValue = servletContext.getAttribute(placeholder); |
||||
if (attrValue != null) { |
||||
value = attrValue.toString(); |
||||
} |
||||
} |
||||
if (value == null) { |
||||
value = servletContext.getInitParameter(placeholder); |
||||
} |
||||
return value; |
||||
} |
||||
|
||||
} |
||||
Loading…
Reference in new issue