Apache
/
commons-lang
mirror of https://github.com/apache/commons-lang.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Avoid boolean boxing in asserts where possible 

git-svn-id: https://svn.apache.org/repos/asf/commons/proper/lang/trunk@1199724 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Sebastian Bazley 2011-11-09 12:51:52 +00:00
parent 40e4babd35
commit f4b810ba42
9 changed files with 198 additions and 195 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

168
src/test/java/org/apache/commons/lang3/BooleanUtilsTest.java
View File

@ -36,9 +36,9 @@ public void testConstructor() {
assertNotNull(new BooleanUtils()); assertNotNull(new BooleanUtils());
Constructor<?>[] cons = BooleanUtils.class.getDeclaredConstructors(); Constructor<?>[] cons = BooleanUtils.class.getDeclaredConstructors();
assertEquals(1, cons.length); assertEquals(1, cons.length);
assertEquals(true, Modifier.isPublic(cons[0].getModifiers())); assertTrue(Modifier.isPublic(cons[0].getModifiers()));
assertEquals(true, Modifier.isPublic(BooleanUtils.class.getModifiers())); assertTrue(Modifier.isPublic(BooleanUtils.class.getModifiers()));
assertEquals(false, Modifier.isFinal(BooleanUtils.class.getModifiers())); assertFalse(Modifier.isFinal(BooleanUtils.class.getModifiers()));
} }
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
@ -52,58 +52,58 @@ public void test_negate_Boolean() {
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
@Test @Test
public void test_isTrue_Boolean() { public void test_isTrue_Boolean() {
assertEquals(true, BooleanUtils.isTrue(Boolean.TRUE)); assertTrue(BooleanUtils.isTrue(Boolean.TRUE));
assertEquals(false, BooleanUtils.isTrue(Boolean.FALSE)); assertFalse(BooleanUtils.isTrue(Boolean.FALSE));
assertEquals(false, BooleanUtils.isTrue((Boolean) null)); assertFalse(BooleanUtils.isTrue((Boolean) null));
} }
@Test @Test
public void test_isNotTrue_Boolean() { public void test_isNotTrue_Boolean() {
assertEquals(false, BooleanUtils.isNotTrue(Boolean.TRUE)); assertFalse(BooleanUtils.isNotTrue(Boolean.TRUE));
assertEquals(true, BooleanUtils.isNotTrue(Boolean.FALSE)); assertTrue(BooleanUtils.isNotTrue(Boolean.FALSE));
assertEquals(true, BooleanUtils.isNotTrue((Boolean) null)); assertTrue(BooleanUtils.isNotTrue((Boolean) null));
} }
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
@Test @Test
public void test_isFalse_Boolean() { public void test_isFalse_Boolean() {
assertEquals(false, BooleanUtils.isFalse(Boolean.TRUE)); assertFalse(BooleanUtils.isFalse(Boolean.TRUE));
assertEquals(true, BooleanUtils.isFalse(Boolean.FALSE)); assertTrue(BooleanUtils.isFalse(Boolean.FALSE));
assertEquals(false, BooleanUtils.isFalse((Boolean) null)); assertFalse(BooleanUtils.isFalse((Boolean) null));
} }
@Test @Test
public void test_isNotFalse_Boolean() { public void test_isNotFalse_Boolean() {
assertEquals(true, BooleanUtils.isNotFalse(Boolean.TRUE)); assertTrue(BooleanUtils.isNotFalse(Boolean.TRUE));
assertEquals(false, BooleanUtils.isNotFalse(Boolean.FALSE)); assertFalse(BooleanUtils.isNotFalse(Boolean.FALSE));
assertEquals(true, BooleanUtils.isNotFalse((Boolean) null)); assertTrue(BooleanUtils.isNotFalse((Boolean) null));
} }
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
@Test @Test
public void test_toBoolean_Boolean() { public void test_toBoolean_Boolean() {
assertEquals(true, BooleanUtils.toBoolean(Boolean.TRUE)); assertTrue(BooleanUtils.toBoolean(Boolean.TRUE));
assertEquals(false, BooleanUtils.toBoolean(Boolean.FALSE)); assertFalse(BooleanUtils.toBoolean(Boolean.FALSE));
assertEquals(false, BooleanUtils.toBoolean((Boolean) null)); assertFalse(BooleanUtils.toBoolean((Boolean) null));
} }
@Test @Test
public void test_toBooleanDefaultIfNull_Boolean_boolean() { public void test_toBooleanDefaultIfNull_Boolean_boolean() {
assertEquals(true, BooleanUtils.toBooleanDefaultIfNull(Boolean.TRUE, true)); assertTrue(BooleanUtils.toBooleanDefaultIfNull(Boolean.TRUE, true));
assertEquals(true, BooleanUtils.toBooleanDefaultIfNull(Boolean.TRUE, false)); assertTrue(BooleanUtils.toBooleanDefaultIfNull(Boolean.TRUE, false));
assertEquals(false, BooleanUtils.toBooleanDefaultIfNull(Boolean.FALSE, true)); assertFalse(BooleanUtils.toBooleanDefaultIfNull(Boolean.FALSE, true));
assertEquals(false, BooleanUtils.toBooleanDefaultIfNull(Boolean.FALSE, false)); assertFalse(BooleanUtils.toBooleanDefaultIfNull(Boolean.FALSE, false));
assertEquals(true, BooleanUtils.toBooleanDefaultIfNull((Boolean) null, true)); assertTrue(BooleanUtils.toBooleanDefaultIfNull((Boolean) null, true));
assertEquals(false, BooleanUtils.toBooleanDefaultIfNull((Boolean) null, false)); assertFalse(BooleanUtils.toBooleanDefaultIfNull((Boolean) null, false));
} }
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
@Test @Test
public void test_toBoolean_int() { public void test_toBoolean_int() {
assertEquals(true, BooleanUtils.toBoolean(1)); assertTrue(BooleanUtils.toBoolean(1));
assertEquals(true, BooleanUtils.toBoolean(-1)); assertTrue(BooleanUtils.toBoolean(-1));
assertEquals(false, BooleanUtils.toBoolean(0)); assertFalse(BooleanUtils.toBoolean(0));
} }
@Test @Test
@ -124,8 +124,8 @@ public void test_toBooleanObject_Integer() {
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
@Test @Test
public void test_toBoolean_int_int_int() { public void test_toBoolean_int_int_int() {
assertEquals(true, BooleanUtils.toBoolean(6, 6, 7)); assertTrue(BooleanUtils.toBoolean(6, 6, 7));
assertEquals(false, BooleanUtils.toBoolean(7, 6, 7)); assertFalse(BooleanUtils.toBoolean(7, 6, 7));
} }
@Test(expected = IllegalArgumentException.class) @Test(expected = IllegalArgumentException.class)
@ -138,11 +138,11 @@ public void test_toBoolean_Integer_Integer_Integer() {
Integer six = Integer.valueOf(6); Integer six = Integer.valueOf(6);
Integer seven = Integer.valueOf(7); Integer seven = Integer.valueOf(7);
assertEquals(true, BooleanUtils.toBoolean((Integer) null, null, seven)); assertTrue(BooleanUtils.toBoolean((Integer) null, null, seven));
assertEquals(false, BooleanUtils.toBoolean((Integer) null, six, null)); assertFalse(BooleanUtils.toBoolean((Integer) null, six, null));
assertEquals(true, BooleanUtils.toBoolean(Integer.valueOf(6), six, seven)); assertTrue(BooleanUtils.toBoolean(Integer.valueOf(6), six, seven));
assertEquals(false, BooleanUtils.toBoolean(Integer.valueOf(7), six, seven)); assertFalse(BooleanUtils.toBoolean(Integer.valueOf(7), six, seven));
} }
@Test(expected = IllegalArgumentException.class) @Test(expected = IllegalArgumentException.class)
@ -306,62 +306,62 @@ public void test_toBooleanObject_String_String_String_String_noMatch() {
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
@Test @Test
public void test_toBoolean_String() { public void test_toBoolean_String() {
assertEquals(false, BooleanUtils.toBoolean((String) null)); assertFalse(BooleanUtils.toBoolean((String) null));
assertEquals(false, BooleanUtils.toBoolean("")); assertFalse(BooleanUtils.toBoolean(""));
assertEquals(false, BooleanUtils.toBoolean("off")); assertFalse(BooleanUtils.toBoolean("off"));
assertEquals(false, BooleanUtils.toBoolean("oof")); assertFalse(BooleanUtils.toBoolean("oof"));
assertEquals(false, BooleanUtils.toBoolean("yep")); assertFalse(BooleanUtils.toBoolean("yep"));
assertEquals(false, BooleanUtils.toBoolean("trux")); assertFalse(BooleanUtils.toBoolean("trux"));
assertEquals(false, BooleanUtils.toBoolean("false")); assertFalse(BooleanUtils.toBoolean("false"));
assertEquals(false, BooleanUtils.toBoolean("a")); assertFalse(BooleanUtils.toBoolean("a"));
assertEquals(true, BooleanUtils.toBoolean("true")); // interned handled differently assertTrue(BooleanUtils.toBoolean("true")); // interned handled differently
assertEquals(true, BooleanUtils.toBoolean(new StringBuffer("tr").append("ue").toString())); assertTrue(BooleanUtils.toBoolean(new StringBuffer("tr").append("ue").toString()));
assertEquals(true, BooleanUtils.toBoolean("truE")); assertTrue(BooleanUtils.toBoolean("truE"));
assertEquals(true, BooleanUtils.toBoolean("trUe")); assertTrue(BooleanUtils.toBoolean("trUe"));
assertEquals(true, BooleanUtils.toBoolean("trUE")); assertTrue(BooleanUtils.toBoolean("trUE"));
assertEquals(true, BooleanUtils.toBoolean("tRue")); assertTrue(BooleanUtils.toBoolean("tRue"));
assertEquals(true, BooleanUtils.toBoolean("tRuE")); assertTrue(BooleanUtils.toBoolean("tRuE"));
assertEquals(true, BooleanUtils.toBoolean("tRUe")); assertTrue(BooleanUtils.toBoolean("tRUe"));
assertEquals(true, BooleanUtils.toBoolean("tRUE")); assertTrue(BooleanUtils.toBoolean("tRUE"));
assertEquals(true, BooleanUtils.toBoolean("TRUE")); assertTrue(BooleanUtils.toBoolean("TRUE"));
assertEquals(true, BooleanUtils.toBoolean("TRUe")); assertTrue(BooleanUtils.toBoolean("TRUe"));
assertEquals(true, BooleanUtils.toBoolean("TRuE")); assertTrue(BooleanUtils.toBoolean("TRuE"));
assertEquals(true, BooleanUtils.toBoolean("TRue")); assertTrue(BooleanUtils.toBoolean("TRue"));
assertEquals(true, BooleanUtils.toBoolean("TrUE")); assertTrue(BooleanUtils.toBoolean("TrUE"));
assertEquals(true, BooleanUtils.toBoolean("TrUe")); assertTrue(BooleanUtils.toBoolean("TrUe"));
assertEquals(true, BooleanUtils.toBoolean("TruE")); assertTrue(BooleanUtils.toBoolean("TruE"));
assertEquals(true, BooleanUtils.toBoolean("True")); assertTrue(BooleanUtils.toBoolean("True"));
assertEquals(true, BooleanUtils.toBoolean("on")); assertTrue(BooleanUtils.toBoolean("on"));
assertEquals(true, BooleanUtils.toBoolean("oN")); assertTrue(BooleanUtils.toBoolean("oN"));
assertEquals(true, BooleanUtils.toBoolean("On")); assertTrue(BooleanUtils.toBoolean("On"));
assertEquals(true, BooleanUtils.toBoolean("ON")); assertTrue(BooleanUtils.toBoolean("ON"));
assertEquals(true, BooleanUtils.toBoolean("yes")); assertTrue(BooleanUtils.toBoolean("yes"));
assertEquals(true, BooleanUtils.toBoolean("yeS")); assertTrue(BooleanUtils.toBoolean("yeS"));
assertEquals(true, BooleanUtils.toBoolean("yEs")); assertTrue(BooleanUtils.toBoolean("yEs"));
assertEquals(true, BooleanUtils.toBoolean("yES")); assertTrue(BooleanUtils.toBoolean("yES"));
assertEquals(true, BooleanUtils.toBoolean("Yes")); assertTrue(BooleanUtils.toBoolean("Yes"));
assertEquals(true, BooleanUtils.toBoolean("YeS")); assertTrue(BooleanUtils.toBoolean("YeS"));
assertEquals(true, BooleanUtils.toBoolean("YEs")); assertTrue(BooleanUtils.toBoolean("YEs"));
assertEquals(true, BooleanUtils.toBoolean("YES")); assertTrue(BooleanUtils.toBoolean("YES"));
assertEquals(false, BooleanUtils.toBoolean("yes?")); assertFalse(BooleanUtils.toBoolean("yes?"));
assertEquals(false, BooleanUtils.toBoolean("tru")); assertFalse(BooleanUtils.toBoolean("tru"));
assertEquals(false, BooleanUtils.toBoolean("no")); assertFalse(BooleanUtils.toBoolean("no"));
assertEquals(false, BooleanUtils.toBoolean("off")); assertFalse(BooleanUtils.toBoolean("off"));
assertEquals(false, BooleanUtils.toBoolean("yoo")); assertFalse(BooleanUtils.toBoolean("yoo"));
} }
@Test @Test
public void test_toBoolean_String_String_String() { public void test_toBoolean_String_String_String() {
assertEquals(true, BooleanUtils.toBoolean((String) null, null, "N")); assertTrue(BooleanUtils.toBoolean((String) null, null, "N"));
assertEquals(false, BooleanUtils.toBoolean((String) null, "Y", null)); assertFalse(BooleanUtils.toBoolean((String) null, "Y", null));
assertEquals(true, BooleanUtils.toBoolean("Y", "Y", "N")); assertTrue(BooleanUtils.toBoolean("Y", "Y", "N"));
assertEquals(true, BooleanUtils.toBoolean("Y", new String("Y"), new String("N"))); assertTrue(BooleanUtils.toBoolean("Y", new String("Y"), new String("N")));
assertEquals(false, BooleanUtils.toBoolean("N", "Y", "N")); assertFalse(BooleanUtils.toBoolean("N", "Y", "N"));
assertEquals(false, BooleanUtils.toBoolean("N", new String("Y"), new String("N"))); assertFalse(BooleanUtils.toBoolean("N", new String("Y"), new String("N")));
assertEquals(true, BooleanUtils.toBoolean((String) null, null, null)); assertTrue(BooleanUtils.toBoolean((String) null, null, null));
assertEquals(true, BooleanUtils.toBoolean("Y", "Y", "Y")); assertTrue(BooleanUtils.toBoolean("Y", "Y", "Y"));
assertEquals(true, BooleanUtils.toBoolean("Y", new String("Y"), new String("Y"))); assertTrue(BooleanUtils.toBoolean("Y", new String("Y"), new String("Y")));
} }
@Test(expected = IllegalArgumentException.class) @Test(expected = IllegalArgumentException.class)

135
src/test/java/org/apache/commons/lang3/CharUtilsTest.java
View File

@ -17,6 +17,7 @@
package org.apache.commons.lang3; package org.apache.commons.lang3;
import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame; import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue; import static org.junit.Assert.assertTrue;
@ -42,9 +43,9 @@ public void testConstructor() {
assertNotNull(new CharUtils()); assertNotNull(new CharUtils());
Constructor<?>[] cons = CharUtils.class.getDeclaredConstructors(); Constructor<?>[] cons = CharUtils.class.getDeclaredConstructors();
assertEquals(1, cons.length); assertEquals(1, cons.length);
assertEquals(true, Modifier.isPublic(cons[0].getModifiers())); assertTrue(Modifier.isPublic(cons[0].getModifiers()));
assertEquals(true, Modifier.isPublic(BooleanUtils.class.getModifiers())); assertTrue(Modifier.isPublic(BooleanUtils.class.getModifiers()));
assertEquals(false, Modifier.isFinal(BooleanUtils.class.getModifiers())); assertFalse(Modifier.isFinal(BooleanUtils.class.getModifiers()));
} }
@Test @Test
@ -211,144 +212,144 @@ public void testToUnicodeEscaped_Character() {
@Test @Test
public void testIsAscii_char() { public void testIsAscii_char() {
assertEquals(true, CharUtils.isAscii('a')); assertTrue(CharUtils.isAscii('a'));
assertEquals(true, CharUtils.isAscii('A')); assertTrue(CharUtils.isAscii('A'));
assertEquals(true, CharUtils.isAscii('3')); assertTrue(CharUtils.isAscii('3'));
assertEquals(true, CharUtils.isAscii('-')); assertTrue(CharUtils.isAscii('-'));
assertEquals(true, CharUtils.isAscii('\n')); assertTrue(CharUtils.isAscii('\n'));
assertEquals(false, CharUtils.isAscii(CHAR_COPY)); assertFalse(CharUtils.isAscii(CHAR_COPY));
for (int i = 0; i < 128; i++) { for (int i = 0; i < 128; i++) {
if (i < 128) { if (i < 128) {
assertEquals(true, CharUtils.isAscii((char) i)); assertTrue(CharUtils.isAscii((char) i));
} else { } else {
assertEquals(false, CharUtils.isAscii((char) i)); assertFalse(CharUtils.isAscii((char) i));
} }
} }
} }
@Test @Test
public void testIsAsciiPrintable_char() { public void testIsAsciiPrintable_char() {
assertEquals(true, CharUtils.isAsciiPrintable('a')); assertTrue(CharUtils.isAsciiPrintable('a'));
assertEquals(true, CharUtils.isAsciiPrintable('A')); assertTrue(CharUtils.isAsciiPrintable('A'));
assertEquals(true, CharUtils.isAsciiPrintable('3')); assertTrue(CharUtils.isAsciiPrintable('3'));
assertEquals(true, CharUtils.isAsciiPrintable('-')); assertTrue(CharUtils.isAsciiPrintable('-'));
assertEquals(false, CharUtils.isAsciiPrintable('\n')); assertFalse(CharUtils.isAsciiPrintable('\n'));
assertEquals(false, CharUtils.isAscii(CHAR_COPY)); assertFalse(CharUtils.isAscii(CHAR_COPY));
for (int i = 0; i < 196; i++) { for (int i = 0; i < 196; i++) {
if (i >= 32 && i <= 126) { if (i >= 32 && i <= 126) {
assertEquals(true, CharUtils.isAsciiPrintable((char) i)); assertTrue(CharUtils.isAsciiPrintable((char) i));
} else { } else {
assertEquals(false, CharUtils.isAsciiPrintable((char) i)); assertFalse(CharUtils.isAsciiPrintable((char) i));
} }
} }
} }
@Test @Test
public void testIsAsciiControl_char() { public void testIsAsciiControl_char() {
assertEquals(false, CharUtils.isAsciiControl('a')); assertFalse(CharUtils.isAsciiControl('a'));
assertEquals(false, CharUtils.isAsciiControl('A')); assertFalse(CharUtils.isAsciiControl('A'));
assertEquals(false, CharUtils.isAsciiControl('3')); assertFalse(CharUtils.isAsciiControl('3'));
assertEquals(false, CharUtils.isAsciiControl('-')); assertFalse(CharUtils.isAsciiControl('-'));
assertEquals(true, CharUtils.isAsciiControl('\n')); assertTrue(CharUtils.isAsciiControl('\n'));
assertEquals(false, CharUtils.isAsciiControl(CHAR_COPY)); assertFalse(CharUtils.isAsciiControl(CHAR_COPY));
for (int i = 0; i < 196; i++) { for (int i = 0; i < 196; i++) {
if (i < 32 || i == 127) { if (i < 32 || i == 127) {
assertEquals(true, CharUtils.isAsciiControl((char) i)); assertTrue(CharUtils.isAsciiControl((char) i));
} else { } else {
assertEquals(false, CharUtils.isAsciiControl((char) i)); assertFalse(CharUtils.isAsciiControl((char) i));
} }
} }
} }
@Test @Test
public void testIsAsciiAlpha_char() { public void testIsAsciiAlpha_char() {
assertEquals(true, CharUtils.isAsciiAlpha('a')); assertTrue(CharUtils.isAsciiAlpha('a'));
assertEquals(true, CharUtils.isAsciiAlpha('A')); assertTrue(CharUtils.isAsciiAlpha('A'));
assertEquals(false, CharUtils.isAsciiAlpha('3')); assertFalse(CharUtils.isAsciiAlpha('3'));
assertEquals(false, CharUtils.isAsciiAlpha('-')); assertFalse(CharUtils.isAsciiAlpha('-'));
assertEquals(false, CharUtils.isAsciiAlpha('\n')); assertFalse(CharUtils.isAsciiAlpha('\n'));
assertEquals(false, CharUtils.isAsciiAlpha(CHAR_COPY)); assertFalse(CharUtils.isAsciiAlpha(CHAR_COPY));
for (int i = 0; i < 196; i++) { for (int i = 0; i < 196; i++) {
if ((i >= 'A' && i <= 'Z') || (i >= 'a' && i <= 'z')) { if ((i >= 'A' && i <= 'Z') || (i >= 'a' && i <= 'z')) {
assertEquals(true, CharUtils.isAsciiAlpha((char) i)); assertTrue(CharUtils.isAsciiAlpha((char) i));
} else { } else {
assertEquals(false, CharUtils.isAsciiAlpha((char) i)); assertFalse(CharUtils.isAsciiAlpha((char) i));
} }
} }
} }
@Test @Test
public void testIsAsciiAlphaUpper_char() { public void testIsAsciiAlphaUpper_char() {
assertEquals(false, CharUtils.isAsciiAlphaUpper('a')); assertFalse(CharUtils.isAsciiAlphaUpper('a'));
assertEquals(true, CharUtils.isAsciiAlphaUpper('A')); assertTrue(CharUtils.isAsciiAlphaUpper('A'));
assertEquals(false, CharUtils.isAsciiAlphaUpper('3')); assertFalse(CharUtils.isAsciiAlphaUpper('3'));
assertEquals(false, CharUtils.isAsciiAlphaUpper('-')); assertFalse(CharUtils.isAsciiAlphaUpper('-'));
assertEquals(false, CharUtils.isAsciiAlphaUpper('\n')); assertFalse(CharUtils.isAsciiAlphaUpper('\n'));
assertEquals(false, CharUtils.isAsciiAlphaUpper(CHAR_COPY)); assertFalse(CharUtils.isAsciiAlphaUpper(CHAR_COPY));
for (int i = 0; i < 196; i++) { for (int i = 0; i < 196; i++) {
if (i >= 'A' && i <= 'Z') { if (i >= 'A' && i <= 'Z') {
assertEquals(true, CharUtils.isAsciiAlphaUpper((char) i)); assertTrue(CharUtils.isAsciiAlphaUpper((char) i));
} else { } else {
assertEquals(false, CharUtils.isAsciiAlphaUpper((char) i)); assertFalse(CharUtils.isAsciiAlphaUpper((char) i));
} }
} }
} }
@Test @Test
public void testIsAsciiAlphaLower_char() { public void testIsAsciiAlphaLower_char() {
assertEquals(true, CharUtils.isAsciiAlphaLower('a')); assertTrue(CharUtils.isAsciiAlphaLower('a'));
assertEquals(false, CharUtils.isAsciiAlphaLower('A')); assertFalse(CharUtils.isAsciiAlphaLower('A'));
assertEquals(false, CharUtils.isAsciiAlphaLower('3')); assertFalse(CharUtils.isAsciiAlphaLower('3'));
assertEquals(false, CharUtils.isAsciiAlphaLower('-')); assertFalse(CharUtils.isAsciiAlphaLower('-'));
assertEquals(false, CharUtils.isAsciiAlphaLower('\n')); assertFalse(CharUtils.isAsciiAlphaLower('\n'));
assertEquals(false, CharUtils.isAsciiAlphaLower(CHAR_COPY)); assertFalse(CharUtils.isAsciiAlphaLower(CHAR_COPY));
for (int i = 0; i < 196; i++) { for (int i = 0; i < 196; i++) {
if (i >= 'a' && i <= 'z') { if (i >= 'a' && i <= 'z') {
assertEquals(true, CharUtils.isAsciiAlphaLower((char) i)); assertTrue(CharUtils.isAsciiAlphaLower((char) i));
} else { } else {
assertEquals(false, CharUtils.isAsciiAlphaLower((char) i)); assertFalse(CharUtils.isAsciiAlphaLower((char) i));
} }
} }
} }
@Test @Test
public void testIsAsciiNumeric_char() { public void testIsAsciiNumeric_char() {
assertEquals(false, CharUtils.isAsciiNumeric('a')); assertFalse(CharUtils.isAsciiNumeric('a'));
assertEquals(false, CharUtils.isAsciiNumeric('A')); assertFalse(CharUtils.isAsciiNumeric('A'));
assertEquals(true, CharUtils.isAsciiNumeric('3')); assertTrue(CharUtils.isAsciiNumeric('3'));
assertEquals(false, CharUtils.isAsciiNumeric('-')); assertFalse(CharUtils.isAsciiNumeric('-'));
assertEquals(false, CharUtils.isAsciiNumeric('\n')); assertFalse(CharUtils.isAsciiNumeric('\n'));
assertEquals(false, CharUtils.isAsciiNumeric(CHAR_COPY)); assertFalse(CharUtils.isAsciiNumeric(CHAR_COPY));
for (int i = 0; i < 196; i++) { for (int i = 0; i < 196; i++) {
if (i >= '0' && i <= '9') { if (i >= '0' && i <= '9') {
assertEquals(true, CharUtils.isAsciiNumeric((char) i)); assertTrue(CharUtils.isAsciiNumeric((char) i));
} else { } else {
assertEquals(false, CharUtils.isAsciiNumeric((char) i)); assertFalse(CharUtils.isAsciiNumeric((char) i));
} }
} }
} }
@Test @Test
public void testIsAsciiAlphanumeric_char() { public void testIsAsciiAlphanumeric_char() {
assertEquals(true, CharUtils.isAsciiAlphanumeric('a')); assertTrue(CharUtils.isAsciiAlphanumeric('a'));
assertEquals(true, CharUtils.isAsciiAlphanumeric('A')); assertTrue(CharUtils.isAsciiAlphanumeric('A'));
assertEquals(true, CharUtils.isAsciiAlphanumeric('3')); assertTrue(CharUtils.isAsciiAlphanumeric('3'));
assertEquals(false, CharUtils.isAsciiAlphanumeric('-')); assertFalse(CharUtils.isAsciiAlphanumeric('-'));
assertEquals(false, CharUtils.isAsciiAlphanumeric('\n')); assertFalse(CharUtils.isAsciiAlphanumeric('\n'));
assertEquals(false, CharUtils.isAsciiAlphanumeric(CHAR_COPY)); assertFalse(CharUtils.isAsciiAlphanumeric(CHAR_COPY));
for (int i = 0; i < 196; i++) { for (int i = 0; i < 196; i++) {
if ((i >= 'A' && i <= 'Z') || (i >= 'a' && i <= 'z') || (i >= '0' && i <= '9')) { if ((i >= 'A' && i <= 'Z') || (i >= 'a' && i <= 'z') || (i >= '0' && i <= '9')) {
assertEquals(true, CharUtils.isAsciiAlphanumeric((char) i)); assertTrue(CharUtils.isAsciiAlphanumeric((char) i));
} else { } else {
assertEquals(false, CharUtils.isAsciiAlphanumeric((char) i)); assertFalse(CharUtils.isAsciiAlphanumeric((char) i));
} }
} }
} }

18
src/test/java/org/apache/commons/lang3/EnumUtilsTest.java
View File

@ -44,13 +44,13 @@ public void test_getEnumMap() {
Map<String, Traffic> test = EnumUtils.getEnumMap(Traffic.class); Map<String, Traffic> test = EnumUtils.getEnumMap(Traffic.class);
assertEquals( "getEnumMap not created correctly", "{RED=RED, AMBER=AMBER, GREEN=GREEN}", test.toString()); assertEquals( "getEnumMap not created correctly", "{RED=RED, AMBER=AMBER, GREEN=GREEN}", test.toString());
assertEquals(3, test.size()); assertEquals(3, test.size());
assertEquals(true, test.containsKey("RED")); assertTrue(test.containsKey("RED"));
assertEquals(Traffic.RED, test.get("RED")); assertEquals(Traffic.RED, test.get("RED"));
assertEquals(true, test.containsKey("AMBER")); assertTrue(test.containsKey("AMBER"));
assertEquals(Traffic.AMBER, test.get("AMBER")); assertEquals(Traffic.AMBER, test.get("AMBER"));
assertEquals(true, test.containsKey("GREEN")); assertTrue(test.containsKey("GREEN"));
assertEquals(Traffic.GREEN, test.get("GREEN")); assertEquals(Traffic.GREEN, test.get("GREEN"));
assertEquals(false, test.containsKey("PURPLE")); assertFalse(test.containsKey("PURPLE"));
} }
@Test @Test
@ -64,11 +64,11 @@ public void test_getEnumList() {
@Test @Test
public void test_isEnum() { public void test_isEnum() {
assertEquals(true, EnumUtils.isValidEnum(Traffic.class, "RED")); assertTrue(EnumUtils.isValidEnum(Traffic.class, "RED"));
assertEquals(true, EnumUtils.isValidEnum(Traffic.class, "AMBER")); assertTrue(EnumUtils.isValidEnum(Traffic.class, "AMBER"));
assertEquals(true, EnumUtils.isValidEnum(Traffic.class, "GREEN")); assertTrue(EnumUtils.isValidEnum(Traffic.class, "GREEN"));
assertEquals(false, EnumUtils.isValidEnum(Traffic.class, "PURPLE")); assertFalse(EnumUtils.isValidEnum(Traffic.class, "PURPLE"));
assertEquals(false, EnumUtils.isValidEnum(Traffic.class, null)); assertFalse(EnumUtils.isValidEnum(Traffic.class, null));
} }
@Test(expected=NullPointerException.class) @Test(expected=NullPointerException.class)

6
src/test/java/org/apache/commons/lang3/ObjectUtilsTest.java
View File

@ -46,9 +46,9 @@ public void testConstructor() {
assertNotNull(new ObjectUtils()); assertNotNull(new ObjectUtils());
Constructor<?>[] cons = ObjectUtils.class.getDeclaredConstructors(); Constructor<?>[] cons = ObjectUtils.class.getDeclaredConstructors();
assertEquals(1, cons.length); assertEquals(1, cons.length);
assertEquals(true, Modifier.isPublic(cons[0].getModifiers())); assertTrue(Modifier.isPublic(cons[0].getModifiers()));
assertEquals(true, Modifier.isPublic(ObjectUtils.class.getModifiers())); assertTrue(Modifier.isPublic(ObjectUtils.class.getModifiers()));
assertEquals(false, Modifier.isFinal(ObjectUtils.class.getModifiers())); assertFalse(Modifier.isFinal(ObjectUtils.class.getModifiers()));
} }
//----------------------------------------------------------------------- //-----------------------------------------------------------------------

8
src/test/java/org/apache/commons/lang3/StringEscapeUtilsTest.java
View File

@ -17,6 +17,7 @@
package org.apache.commons.lang3; package org.apache.commons.lang3;
import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue; import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail; import static org.junit.Assert.fail;
@ -32,7 +33,6 @@
import org.apache.commons.lang3.text.translate.CharSequenceTranslator; import org.apache.commons.lang3.text.translate.CharSequenceTranslator;
import org.apache.commons.lang3.text.translate.NumericEntityEscaper; import org.apache.commons.lang3.text.translate.NumericEntityEscaper;
import org.apache.commons.lang3.text.translate.NumericEntityUnescaper;
/** /**
* Unit tests for {@link StringEscapeUtils}. * Unit tests for {@link StringEscapeUtils}.
@ -47,9 +47,9 @@ public void testConstructor() {
assertNotNull(new StringEscapeUtils()); assertNotNull(new StringEscapeUtils());
Constructor<?>[] cons = StringEscapeUtils.class.getDeclaredConstructors(); Constructor<?>[] cons = StringEscapeUtils.class.getDeclaredConstructors();
assertEquals(1, cons.length); assertEquals(1, cons.length);
assertEquals(true, Modifier.isPublic(cons[0].getModifiers())); assertTrue(Modifier.isPublic(cons[0].getModifiers()));
assertEquals(true, Modifier.isPublic(StringEscapeUtils.class.getModifiers())); assertTrue(Modifier.isPublic(StringEscapeUtils.class.getModifiers()));
assertEquals(false, Modifier.isFinal(StringEscapeUtils.class.getModifiers())); assertFalse(Modifier.isFinal(StringEscapeUtils.class.getModifiers()));
} }
@Test @Test

12
src/test/java/org/apache/commons/lang3/StringUtilsTest.java
View File

@ -106,9 +106,9 @@ public void testConstructor() {
assertNotNull(new StringUtils()); assertNotNull(new StringUtils());
Constructor<?>[] cons = StringUtils.class.getDeclaredConstructors(); Constructor<?>[] cons = StringUtils.class.getDeclaredConstructors();
assertEquals(1, cons.length); assertEquals(1, cons.length);
assertEquals(true, Modifier.isPublic(cons[0].getModifiers())); assertTrue(Modifier.isPublic(cons[0].getModifiers()));
assertEquals(true, Modifier.isPublic(StringUtils.class.getModifiers())); assertTrue(Modifier.isPublic(StringUtils.class.getModifiers()));
assertEquals(false, Modifier.isFinal(StringUtils.class.getModifiers())); assertFalse(Modifier.isFinal(StringUtils.class.getModifiers()));
} }
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
@ -1186,7 +1186,7 @@ public void testRepeat_StringInt() {
assertEquals("abcabcabc", StringUtils.repeat("abc", 3)); assertEquals("abcabcabc", StringUtils.repeat("abc", 3));
String str = StringUtils.repeat("a", 10000); // bigger than pad limit String str = StringUtils.repeat("a", 10000); // bigger than pad limit
assertEquals(10000, str.length()); assertEquals(10000, str.length());
assertEquals(true, StringUtils.containsOnly(str, new char[] {'a'})); assertTrue(StringUtils.containsOnly(str, new char[] {'a'}));
} }
@Test @Test
@ -1306,7 +1306,7 @@ public void testRightPad_StringIntChar() {
assertEquals("abcxx", StringUtils.rightPad("abc", 5, 'x')); assertEquals("abcxx", StringUtils.rightPad("abc", 5, 'x'));
String str = StringUtils.rightPad("aaa", 10000, 'a'); // bigger than pad length String str = StringUtils.rightPad("aaa", 10000, 'a'); // bigger than pad length
assertEquals(10000, str.length()); assertEquals(10000, str.length());
assertEquals(true, StringUtils.containsOnly(str, new char[] {'a'})); assertTrue(StringUtils.containsOnly(str, new char[] {'a'}));
} }
@Test @Test
@ -1342,7 +1342,7 @@ public void testLeftPad_StringIntChar() {
assertEquals("abc", StringUtils.leftPad("abc", 2, ' ')); assertEquals("abc", StringUtils.leftPad("abc", 2, ' '));
String str = StringUtils.leftPad("aaa", 10000, 'a'); // bigger than pad length String str = StringUtils.leftPad("aaa", 10000, 'a'); // bigger than pad length
assertEquals(10000, str.length()); assertEquals(10000, str.length());
assertEquals(true, StringUtils.containsOnly(str, new char[] {'a'})); assertTrue(StringUtils.containsOnly(str, new char[] {'a'}));
} }
@Test @Test

22
src/test/java/org/apache/commons/lang3/builder/EqualsBuilderTest.java
View File

@ -285,10 +285,10 @@ private void testReflectionEqualsEquivalenceRelationship(
public void testSuper() { public void testSuper() {
TestObject o1 = new TestObject(4); TestObject o1 = new TestObject(4);
TestObject o2 = new TestObject(5); TestObject o2 = new TestObject(5);
assertEquals(true, new EqualsBuilder().appendSuper(true).append(o1, o1).isEquals()); assertTrue(new EqualsBuilder().appendSuper(true).append(o1, o1).isEquals());
assertEquals(false, new EqualsBuilder().appendSuper(false).append(o1, o1).isEquals()); assertFalse(new EqualsBuilder().appendSuper(false).append(o1, o1).isEquals());
assertEquals(false, new EqualsBuilder().appendSuper(true).append(o1, o2).isEquals()); assertFalse(new EqualsBuilder().appendSuper(true).append(o1, o2).isEquals());
assertEquals(false, new EqualsBuilder().appendSuper(false).append(o1, o2).isEquals()); assertFalse(new EqualsBuilder().appendSuper(false).append(o1, o2).isEquals());
} }
@Test @Test
@ -311,16 +311,16 @@ public void testObject() {
public void testObjectBuild() { public void testObjectBuild() {
TestObject o1 = new TestObject(4); TestObject o1 = new TestObject(4);
TestObject o2 = new TestObject(5); TestObject o2 = new TestObject(5);
assertTrue(new EqualsBuilder().append(o1, o1).build()); assertEquals(Boolean.TRUE, new EqualsBuilder().append(o1, o1).build());
assertTrue(!new EqualsBuilder().append(o1, o2).build()); assertEquals(Boolean.FALSE, new EqualsBuilder().append(o1, o2).build());
o2.setA(4); o2.setA(4);
assertTrue(new EqualsBuilder().append(o1, o2).build()); assertEquals(Boolean.TRUE, new EqualsBuilder().append(o1, o2).build());
assertTrue(!new EqualsBuilder().append(o1, this).build()); assertEquals(Boolean.FALSE, new EqualsBuilder().append(o1, this).build());
assertTrue(!new EqualsBuilder().append(o1, null).build()); assertEquals(Boolean.FALSE, new EqualsBuilder().append(o1, null).build());
assertTrue(!new EqualsBuilder().append(null, o2).build()); assertEquals(Boolean.FALSE, new EqualsBuilder().append(null, o2).build());
assertTrue(new EqualsBuilder().append((Object) null, (Object) null).build()); assertEquals(Boolean.TRUE, new EqualsBuilder().append((Object) null, (Object) null).build());
} }
@Test @Test

8
src/test/java/org/apache/commons/lang3/reflect/FieldUtilsTest.java
View File

@ -17,8 +17,10 @@
package org.apache.commons.lang3.reflect; package org.apache.commons.lang3.reflect;
import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull; import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail; import static org.junit.Assert.fail;
import static org.junit.Assume.assumeNotNull; import static org.junit.Assume.assumeNotNull;
@ -67,9 +69,9 @@ public void testConstructor() {
assertNotNull(new FieldUtils()); assertNotNull(new FieldUtils());
Constructor<?>[] cons = FieldUtils.class.getDeclaredConstructors(); Constructor<?>[] cons = FieldUtils.class.getDeclaredConstructors();
assertEquals(1, cons.length); assertEquals(1, cons.length);
assertEquals(true, Modifier.isPublic(cons[0].getModifiers())); assertTrue(Modifier.isPublic(cons[0].getModifiers()));
assertEquals(true, Modifier.isPublic(FieldUtils.class.getModifiers())); assertTrue(Modifier.isPublic(FieldUtils.class.getModifiers()));
assertEquals(false, Modifier.isFinal(FieldUtils.class.getModifiers())); assertFalse(Modifier.isFinal(FieldUtils.class.getModifiers()));
} }
@Test @Test

16
src/test/java/org/apache/commons/lang3/tuple/PairTest.java
View File

@ -76,20 +76,20 @@ public void testMapEntry() throws Exception {
public void testComparable1() throws Exception { public void testComparable1() throws Exception {
Pair<String, String> pair1 = Pair.of("A", "D"); Pair<String, String> pair1 = Pair.of("A", "D");
Pair<String, String> pair2 = Pair.of("B", "C"); Pair<String, String> pair2 = Pair.of("B", "C");
assertEquals(true, pair1.compareTo(pair1) == 0); assertTrue(pair1.compareTo(pair1) == 0);
assertEquals(true, pair1.compareTo(pair2) < 0); assertTrue(pair1.compareTo(pair2) < 0);
assertEquals(true, pair2.compareTo(pair2) == 0); assertTrue(pair2.compareTo(pair2) == 0);
assertEquals(true, pair2.compareTo(pair1) > 0); assertTrue(pair2.compareTo(pair1) > 0);
} }
@Test @Test
public void testComparable2() throws Exception { public void testComparable2() throws Exception {
Pair<String, String> pair1 = Pair.of("A", "C"); Pair<String, String> pair1 = Pair.of("A", "C");
Pair<String, String> pair2 = Pair.of("A", "D"); Pair<String, String> pair2 = Pair.of("A", "D");
assertEquals(true, pair1.compareTo(pair1) == 0); assertTrue(pair1.compareTo(pair1) == 0);
assertEquals(true, pair1.compareTo(pair2) < 0); assertTrue(pair1.compareTo(pair2) < 0);
assertEquals(true, pair2.compareTo(pair2) == 0); assertTrue(pair2.compareTo(pair2) == 0);
assertEquals(true, pair2.compareTo(pair1) > 0); assertTrue(pair2.compareTo(pair1) > 0);
} }
@Test @Test