root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions 8 Packages Projects Releases Wiki Activity

Changed use of AssertThrows to @Test(expected = ...)

This commit is contained in:
Arjen Poutsma 2008-10-31 08:57:10 +00:00
parent 19debfb080
commit 2cf6dc4480
1 changed files with 104 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

139
org.springframework.testsuite/src/test/java/org/springframework/util/AssertTests.java
View File

@ -16,10 +16,15 @@
package org.springframework.util; package org.springframework.util;
import junit.framework.TestCase; import java.util.ArrayList;
import org.springframework.test.AssertThrows; import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.*; import org.junit.Test;
/** /**
* Unit tests for the {@link Assert} class. * Unit tests for the {@link Assert} class.
@ -27,157 +32,123 @@ import java.util.*;
* @author Keith Donald * @author Keith Donald
* @author Erwin Vervaet * @author Erwin Vervaet
* @author Rick Evans * @author Rick Evans
* @author Arjen Poutsma
*/ */
public class AssertTests extends TestCase { public class AssertTests {
public void testInstanceOf() { @Test(expected = IllegalArgumentException.class)
public void instanceOf() {
final Set set = new HashSet(); final Set set = new HashSet();
Assert.isInstanceOf(HashSet.class, set); Assert.isInstanceOf(HashSet.class, set);
new AssertThrows(IllegalArgumentException.class, "a hash map is not a set") {
public void test() throws Exception {
Assert.isInstanceOf(HashMap.class, set); Assert.isInstanceOf(HashMap.class, set);
} }
}.runTest();
}
public void testIsNullDoesNotThrowExceptionIfArgumentIsNullWithMessage() { @Test
public void isNullDoesNotThrowExceptionIfArgumentIsNullWithMessage() {
Assert.isNull(null, "Bla"); Assert.isNull(null, "Bla");
} }
public void testIsNullDoesNotThrowExceptionIfArgumentIsNull() { @Test
public void isNullDoesNotThrowExceptionIfArgumentIsNull() {
Assert.isNull(null); Assert.isNull(null);
} }
public void testIsNullThrowsExceptionIfArgumentIsNotNull() { @Test(expected = IllegalArgumentException.class)
new AssertThrows(IllegalArgumentException.class, "object is not null") { public void isNullThrowsExceptionIfArgumentIsNotNull() {
public void test() throws Exception {
Assert.isNull(new Object()); Assert.isNull(new Object());
} }
}.runTest();
}
public void testIsNullThrowsExceptionIfArgumentIsNotNullWithMessage() { @Test(expected = IllegalArgumentException.class)
new AssertThrows(IllegalArgumentException.class, "object is not null") { public void isTrueWithFalseExpressionThrowsException() throws Exception {
public void test() throws Exception {
Assert.isNull(new Object(), "Bla");
}
protected void checkExceptionExpectations(Exception actualException) {
assertEquals("Bla", actualException.getMessage());
super.checkExceptionExpectations(actualException);
}
}.runTest();
}
public void testIsTrueWithFalseExpressionThrowsException() throws Exception {
new AssertThrows(IllegalArgumentException.class) {
public void test() throws Exception {
Assert.isTrue(false); Assert.isTrue(false);
} }
}.runTest();
}
public void testIsTrueWithTrueExpressionSunnyDay() throws Exception { @Test
public void isTrueWithTrueExpressionSunnyDay() throws Exception {
Assert.isTrue(true); Assert.isTrue(true);
} }
@Test(expected = IllegalArgumentException.class)
public void testHasLengthWithNullStringThrowsException() throws Exception { public void testHasLengthWithNullStringThrowsException() throws Exception {
new AssertThrows(IllegalArgumentException.class) {
public void test() throws Exception {
Assert.hasLength(null); Assert.hasLength(null);
} }
}.runTest();
}
public void testHasLengthWithEmptyStringThrowsException() throws Exception { @Test(expected = IllegalArgumentException.class)
new AssertThrows(IllegalArgumentException.class) { public void hasLengthWithEmptyStringThrowsException() throws Exception {
public void test() throws Exception {
Assert.hasLength(""); Assert.hasLength("");
} }
}.runTest();
}
public void testHasLengthWithWhitespaceOnlyStringDoesNotThrowException() throws Exception { @Test
public void hasLengthWithWhitespaceOnlyStringDoesNotThrowException() throws Exception {
Assert.hasLength("\t "); Assert.hasLength("\t ");
} }
public void testHasLengthSunnyDay() throws Exception { @Test
public void hasLengthSunnyDay() throws Exception {
Assert.hasLength("I Heart ..."); Assert.hasLength("I Heart ...");
} }
public void testDoesNotContainWithNullSearchStringDoesNotThrowException() throws Exception { @Test
public void doesNotContainWithNullSearchStringDoesNotThrowException() throws Exception {
Assert.doesNotContain(null, "rod"); Assert.doesNotContain(null, "rod");
} }
public void testDoesNotContainWithNullSubstringDoesNotThrowException() throws Exception { @Test
public void doesNotContainWithNullSubstringDoesNotThrowException() throws Exception {
Assert.doesNotContain("A cool chick's name is Brod. ", null); Assert.doesNotContain("A cool chick's name is Brod. ", null);
} }
public void testDoesNotContainWithEmptySubstringDoesNotThrowException() throws Exception { @Test
public void doesNotContainWithEmptySubstringDoesNotThrowException() throws Exception {
Assert.doesNotContain("A cool chick's name is Brod. ", ""); Assert.doesNotContain("A cool chick's name is Brod. ", "");
} }
public void testAssertNotEmptyWithNullCollectionThrowsException() throws Exception { @Test(expected = IllegalArgumentException.class)
new AssertThrows(IllegalArgumentException.class) { public void assertNotEmptyWithNullCollectionThrowsException() throws Exception {
public void test() throws Exception {
Assert.notEmpty((Collection) null); Assert.notEmpty((Collection) null);
} }
}.runTest();
}
public void testAssertNotEmptyWithEmptyCollectionThrowsException() throws Exception { @Test(expected = IllegalArgumentException.class)
new AssertThrows(IllegalArgumentException.class) { public void assertNotEmptyWithEmptyCollectionThrowsException() throws Exception {
public void test() throws Exception {
Assert.notEmpty(new ArrayList()); Assert.notEmpty(new ArrayList());
} }
}.runTest();
}
public void testAssertNotEmptyWithCollectionSunnyDay() throws Exception { @Test
List collection = new ArrayList(); public void assertNotEmptyWithCollectionSunnyDay() throws Exception {
List<String> collection = new ArrayList<String>();
collection.add(""); collection.add("");
Assert.notEmpty(collection); Assert.notEmpty(collection);
} }
public void testAssertNotEmptyWithNullMapThrowsException() throws Exception { @Test(expected = IllegalArgumentException.class)
new AssertThrows(IllegalArgumentException.class) { public void assertNotEmptyWithNullMapThrowsException() throws Exception {
public void test() throws Exception {
Assert.notEmpty((Map) null); Assert.notEmpty((Map) null);
} }
}.runTest();
}
public void testAssertNotEmptyWithEmptyMapThrowsException() throws Exception { @Test(expected = IllegalArgumentException.class)
new AssertThrows(IllegalArgumentException.class) { public void assertNotEmptyWithEmptyMapThrowsException() throws Exception {
public void test() throws Exception {
Assert.notEmpty(new HashMap()); Assert.notEmpty(new HashMap());
} }
}.runTest();
}
public void testAssertNotEmptyWithMapSunnyDay() throws Exception { @Test
Map map = new HashMap(); public void assertNotEmptyWithMapSunnyDay() throws Exception {
Map<String, String> map = new HashMap<String, String>();
map.put("", ""); map.put("", "");
Assert.notEmpty(map); Assert.notEmpty(map);
} }
public void testIsInstanceofClassWithNullInstanceThrowsException() throws Exception { @Test(expected = IllegalArgumentException.class)
new AssertThrows(IllegalArgumentException.class) { public void isInstanceofClassWithNullInstanceThrowsException() throws Exception {
public void test() throws Exception {
Assert.isInstanceOf(String.class, null); Assert.isInstanceOf(String.class, null);
} }
}.runTest();
}
public void testStateWithFalseExpressionThrowsException() throws Exception { @Test(expected = IllegalStateException.class)
new AssertThrows(IllegalStateException.class) { public void stateWithFalseExpressionThrowsException() throws Exception {
public void test() throws Exception {
Assert.state(false); Assert.state(false);
} }
}.runTest();
}
public void testStateWithTrueExpressionSunnyDay() throws Exception { @Test
public void stateWithTrueExpressionSunnyDay() throws Exception {
Assert.state(true); Assert.state(true);
} }