diff --git a/spring-core/src/main/java/org/springframework/util/StringUtils.java b/spring-core/src/main/java/org/springframework/util/StringUtils.java index b659486a19d..9ed12a1ea62 100644 --- a/spring-core/src/main/java/org/springframework/util/StringUtils.java +++ b/spring-core/src/main/java/org/springframework/util/StringUtils.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2013 the original author or authors. + * 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. @@ -51,7 +51,6 @@ import java.util.TreeSet; * @author Rick Evans * @author Arjen Poutsma * @since 16 April 2001 - * @see org.apache.commons.lang.StringUtils */ public abstract class StringUtils { @@ -696,7 +695,7 @@ public abstract class StringUtils { if (parts.length > 2) { // There is definitely a variant, and it is everything after the country // code sans the separator between the country code and the variant. - int endIndexOfCountryCode = localeString.lastIndexOf(country) + country.length(); + int endIndexOfCountryCode = localeString.indexOf(country, language.length()) + country.length(); // Strip off any leading '_' and whitespace, what's left is the variant. variant = trimLeadingWhitespace(localeString.substring(endIndexOfCountryCode)); if (variant.startsWith("_")) { diff --git a/spring-core/src/test/java/org/springframework/util/ObjectUtilsTests.java b/spring-core/src/test/java/org/springframework/util/ObjectUtilsTests.java index 800a0ac19aa..8f4c1e28221 100644 --- a/spring-core/src/test/java/org/springframework/util/ObjectUtilsTests.java +++ b/spring-core/src/test/java/org/springframework/util/ObjectUtilsTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2013 the original author or authors. + * 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. @@ -19,7 +19,7 @@ package org.springframework.util; import java.io.IOException; import java.sql.SQLException; -import junit.framework.TestCase; +import org.junit.Test; import org.springframework.core.task.TaskRejectedException; @@ -31,8 +31,9 @@ import static org.junit.Assert.*; * @author Juergen Hoeller * @author Rick Evans */ -public final class ObjectUtilsTests extends TestCase { +public class ObjectUtilsTests { + @Test public void testIsCheckedException() { assertTrue(ObjectUtils.isCheckedException(new Exception())); assertTrue(ObjectUtils.isCheckedException(new SQLException())); @@ -45,6 +46,7 @@ public final class ObjectUtilsTests extends TestCase { assertTrue(ObjectUtils.isCheckedException(new Throwable())); } + @Test public void testIsCompatibleWithThrowsClause() { Class[] empty = new Class[0]; Class[] exception = new Class[] {Exception.class}; @@ -76,6 +78,7 @@ public final class ObjectUtilsTests extends TestCase { assertTrue(ObjectUtils.isCompatibleWithThrowsClause(new Throwable(), throwable)); } + @Test public void testToObjectArray() { int[] a = new int[] {1, 2, 3, 4, 5}; Integer[] wrapper = (Integer[]) ObjectUtils.toObjectArray(a); @@ -85,18 +88,21 @@ public final class ObjectUtilsTests extends TestCase { } } + @Test public void testToObjectArrayWithNull() { Object[] objects = ObjectUtils.toObjectArray(null); assertNotNull(objects); assertEquals(0, objects.length); } + @Test public void testToObjectArrayWithEmptyPrimitiveArray() { Object[] objects = ObjectUtils.toObjectArray(new byte[] {}); assertNotNull(objects); assertEquals(0, objects.length); } + @Test public void testToObjectArrayWithNonArrayType() { try { ObjectUtils.toObjectArray("Not an []"); @@ -106,11 +112,13 @@ public final class ObjectUtilsTests extends TestCase { } } + @Test public void testToObjectArrayWithNonPrimitiveArray() { String[] source = new String[] {"Bingo"}; - assertEquals(source, ObjectUtils.toObjectArray(source)); + assertArrayEquals(source, ObjectUtils.toObjectArray(source)); } + @Test public void testAddObjectToArraySunnyDay() { String[] array = new String[] {"foo", "bar"}; String newElement = "baz"; @@ -119,6 +127,7 @@ public final class ObjectUtilsTests extends TestCase { assertEquals(newElement, newArray[2]); } + @Test public void testAddObjectToArrayWhenEmpty() { String[] array = new String[0]; String newElement = "foo"; @@ -127,6 +136,7 @@ public final class ObjectUtilsTests extends TestCase { assertEquals(newElement, newArray[0]); } + @Test public void testAddObjectToSingleNonNullElementArray() { String existingElement = "foo"; String[] array = new String[] {existingElement}; @@ -137,6 +147,7 @@ public final class ObjectUtilsTests extends TestCase { assertEquals(newElement, newArray[1]); } + @Test public void testAddObjectToSingleNullElementArray() { String[] array = new String[] {null}; String newElement = "bar"; @@ -146,6 +157,7 @@ public final class ObjectUtilsTests extends TestCase { assertEquals(newElement, newArray[1]); } + @Test public void testAddObjectToNullArray() throws Exception { String newElement = "foo"; String[] newArray = ObjectUtils.addObjectToArray(null, newElement); @@ -153,45 +165,53 @@ public final class ObjectUtilsTests extends TestCase { assertEquals(newElement, newArray[0]); } + @Test public void testAddNullObjectToNullArray() throws Exception { Object[] newArray = ObjectUtils.addObjectToArray(null, null); assertEquals(1, newArray.length); assertEquals(null, newArray[0]); } + @Test public void testNullSafeEqualsWithArrays() throws Exception { assertTrue(ObjectUtils.nullSafeEquals(new String[] {"a", "b", "c"}, new String[] {"a", "b", "c"})); assertTrue(ObjectUtils.nullSafeEquals(new int[] {1, 2, 3}, new int[] {1, 2, 3})); } + @Test public void testHashCodeWithBooleanFalse() { int expected = Boolean.FALSE.hashCode(); assertEquals(expected, ObjectUtils.hashCode(false)); } + @Test public void testHashCodeWithBooleanTrue() { int expected = Boolean.TRUE.hashCode(); assertEquals(expected, ObjectUtils.hashCode(true)); } + @Test public void testHashCodeWithDouble() { double dbl = 9830.43; int expected = (new Double(dbl)).hashCode(); assertEquals(expected, ObjectUtils.hashCode(dbl)); } + @Test public void testHashCodeWithFloat() { float flt = 34.8f; int expected = (new Float(flt)).hashCode(); assertEquals(expected, ObjectUtils.hashCode(flt)); } + @Test public void testHashCodeWithLong() { long lng = 883l; int expected = (new Long(lng)).hashCode(); assertEquals(expected, ObjectUtils.hashCode(lng)); } + @Test public void testIdentityToString() { Object obj = new Object(); String expected = obj.getClass().getName() + "@" + ObjectUtils.getIdentityHexString(obj); @@ -199,90 +219,112 @@ public final class ObjectUtilsTests extends TestCase { assertEquals(expected, actual); } + @Test public void testIdentityToStringWithNullObject() { assertEquals("", ObjectUtils.identityToString(null)); } + @Test public void testIsArrayOfPrimitivesWithBooleanArray() { assertTrue(ClassUtils.isPrimitiveArray(boolean[].class)); } + @Test public void testIsArrayOfPrimitivesWithObjectArray() { assertFalse(ClassUtils.isPrimitiveArray(Object[].class)); } + @Test public void testIsArrayOfPrimitivesWithNonArray() { assertFalse(ClassUtils.isPrimitiveArray(String.class)); } + @Test public void testIsPrimitiveOrWrapperWithBooleanPrimitiveClass() { assertTrue(ClassUtils.isPrimitiveOrWrapper(boolean.class)); } + @Test public void testIsPrimitiveOrWrapperWithBooleanWrapperClass() { assertTrue(ClassUtils.isPrimitiveOrWrapper(Boolean.class)); } + @Test public void testIsPrimitiveOrWrapperWithBytePrimitiveClass() { assertTrue(ClassUtils.isPrimitiveOrWrapper(byte.class)); } + @Test public void testIsPrimitiveOrWrapperWithByteWrapperClass() { assertTrue(ClassUtils.isPrimitiveOrWrapper(Byte.class)); } + @Test public void testIsPrimitiveOrWrapperWithCharacterClass() { assertTrue(ClassUtils.isPrimitiveOrWrapper(Character.class)); } + @Test public void testIsPrimitiveOrWrapperWithCharClass() { assertTrue(ClassUtils.isPrimitiveOrWrapper(char.class)); } + @Test public void testIsPrimitiveOrWrapperWithDoublePrimitiveClass() { assertTrue(ClassUtils.isPrimitiveOrWrapper(double.class)); } + @Test public void testIsPrimitiveOrWrapperWithDoubleWrapperClass() { assertTrue(ClassUtils.isPrimitiveOrWrapper(Double.class)); } + @Test public void testIsPrimitiveOrWrapperWithFloatPrimitiveClass() { assertTrue(ClassUtils.isPrimitiveOrWrapper(float.class)); } + @Test public void testIsPrimitiveOrWrapperWithFloatWrapperClass() { assertTrue(ClassUtils.isPrimitiveOrWrapper(Float.class)); } + @Test public void testIsPrimitiveOrWrapperWithIntClass() { assertTrue(ClassUtils.isPrimitiveOrWrapper(int.class)); } + @Test public void testIsPrimitiveOrWrapperWithIntegerClass() { assertTrue(ClassUtils.isPrimitiveOrWrapper(Integer.class)); } + @Test public void testIsPrimitiveOrWrapperWithLongPrimitiveClass() { assertTrue(ClassUtils.isPrimitiveOrWrapper(long.class)); } + @Test public void testIsPrimitiveOrWrapperWithLongWrapperClass() { assertTrue(ClassUtils.isPrimitiveOrWrapper(Long.class)); } + @Test public void testIsPrimitiveOrWrapperWithNonPrimitiveOrWrapperClass() { assertFalse(ClassUtils.isPrimitiveOrWrapper(Object.class)); } + @Test public void testIsPrimitiveOrWrapperWithShortPrimitiveClass() { assertTrue(ClassUtils.isPrimitiveOrWrapper(short.class)); } + @Test public void testIsPrimitiveOrWrapperWithShortWrapperClass() { assertTrue(ClassUtils.isPrimitiveOrWrapper(Short.class)); } + @Test public void testNullSafeHashCodeWithBooleanArray() { int expected = 31 * 7 + Boolean.TRUE.hashCode(); expected = 31 * expected + Boolean.FALSE.hashCode(); @@ -293,10 +335,12 @@ public final class ObjectUtilsTests extends TestCase { assertEquals(expected, actual); } + @Test public void testNullSafeHashCodeWithBooleanArrayEqualToNull() { assertEquals(0, ObjectUtils.nullSafeHashCode((boolean[]) null)); } + @Test public void testNullSafeHashCodeWithByteArray() { int expected = 31 * 7 + 8; expected = 31 * expected + 10; @@ -307,10 +351,12 @@ public final class ObjectUtilsTests extends TestCase { assertEquals(expected, actual); } + @Test public void testNullSafeHashCodeWithByteArrayEqualToNull() { assertEquals(0, ObjectUtils.nullSafeHashCode((byte[]) null)); } + @Test public void testNullSafeHashCodeWithCharArray() { int expected = 31 * 7 + 'a'; expected = 31 * expected + 'E'; @@ -321,10 +367,12 @@ public final class ObjectUtilsTests extends TestCase { assertEquals(expected, actual); } + @Test public void testNullSafeHashCodeWithCharArrayEqualToNull() { assertEquals(0, ObjectUtils.nullSafeHashCode((char[]) null)); } + @Test public void testNullSafeHashCodeWithDoubleArray() { long bits = Double.doubleToLongBits(8449.65); int expected = 31 * 7 + (int) (bits ^ (bits >>> 32)); @@ -337,10 +385,12 @@ public final class ObjectUtilsTests extends TestCase { assertEquals(expected, actual); } + @Test public void testNullSafeHashCodeWithDoubleArrayEqualToNull() { assertEquals(0, ObjectUtils.nullSafeHashCode((double[]) null)); } + @Test public void testNullSafeHashCodeWithFloatArray() { int expected = 31 * 7 + Float.floatToIntBits(9.6f); expected = 31 * expected + Float.floatToIntBits(7.4f); @@ -351,10 +401,12 @@ public final class ObjectUtilsTests extends TestCase { assertEquals(expected, actual); } + @Test public void testNullSafeHashCodeWithFloatArrayEqualToNull() { assertEquals(0, ObjectUtils.nullSafeHashCode((float[]) null)); } + @Test public void testNullSafeHashCodeWithIntArray() { int expected = 31 * 7 + 884; expected = 31 * expected + 340; @@ -365,10 +417,12 @@ public final class ObjectUtilsTests extends TestCase { assertEquals(expected, actual); } + @Test public void testNullSafeHashCodeWithIntArrayEqualToNull() { assertEquals(0, ObjectUtils.nullSafeHashCode((int[]) null)); } + @Test public void testNullSafeHashCodeWithLongArray() { long lng = 7993l; int expected = 31 * 7 + (int) (lng ^ (lng >>> 32)); @@ -381,15 +435,18 @@ public final class ObjectUtilsTests extends TestCase { assertEquals(expected, actual); } + @Test public void testNullSafeHashCodeWithLongArrayEqualToNull() { assertEquals(0, ObjectUtils.nullSafeHashCode((long[]) null)); } + @Test public void testNullSafeHashCodeWithObject() { String str = "Luke"; assertEquals(str.hashCode(), ObjectUtils.nullSafeHashCode(str)); } + @Test public void testNullSafeHashCodeWithObjectArray() { int expected = 31 * 7 + "Leia".hashCode(); expected = 31 * expected + "Han".hashCode(); @@ -400,68 +457,80 @@ public final class ObjectUtilsTests extends TestCase { assertEquals(expected, actual); } + @Test public void testNullSafeHashCodeWithObjectArrayEqualToNull() { assertEquals(0, ObjectUtils.nullSafeHashCode((Object[]) null)); } + @Test public void testNullSafeHashCodeWithObjectBeingBooleanArray() { Object array = new boolean[] {true, false}; int expected = ObjectUtils.nullSafeHashCode((boolean[]) array); assertEqualHashCodes(expected, array); } + @Test public void testNullSafeHashCodeWithObjectBeingByteArray() { Object array = new byte[] {6, 39}; int expected = ObjectUtils.nullSafeHashCode((byte[]) array); assertEqualHashCodes(expected, array); } + @Test public void testNullSafeHashCodeWithObjectBeingCharArray() { Object array = new char[] {'l', 'M'}; int expected = ObjectUtils.nullSafeHashCode((char[]) array); assertEqualHashCodes(expected, array); } + @Test public void testNullSafeHashCodeWithObjectBeingDoubleArray() { Object array = new double[] {68930.993, 9022.009}; int expected = ObjectUtils.nullSafeHashCode((double[]) array); assertEqualHashCodes(expected, array); } + @Test public void testNullSafeHashCodeWithObjectBeingFloatArray() { Object array = new float[] {9.9f, 9.54f}; int expected = ObjectUtils.nullSafeHashCode((float[]) array); assertEqualHashCodes(expected, array); } + @Test public void testNullSafeHashCodeWithObjectBeingIntArray() { Object array = new int[] {89, 32}; int expected = ObjectUtils.nullSafeHashCode((int[]) array); assertEqualHashCodes(expected, array); } + @Test public void testNullSafeHashCodeWithObjectBeingLongArray() { Object array = new long[] {4389, 320}; int expected = ObjectUtils.nullSafeHashCode((long[]) array); assertEqualHashCodes(expected, array); } + @Test public void testNullSafeHashCodeWithObjectBeingObjectArray() { Object array = new Object[] {"Luke", "Anakin"}; int expected = ObjectUtils.nullSafeHashCode((Object[]) array); assertEqualHashCodes(expected, array); } + @Test public void testNullSafeHashCodeWithObjectBeingShortArray() { Object array = new short[] {5, 3}; int expected = ObjectUtils.nullSafeHashCode((short[]) array); assertEqualHashCodes(expected, array); } + @Test public void testNullSafeHashCodeWithObjectEqualToNull() { assertEquals(0, ObjectUtils.nullSafeHashCode((Object) null)); } + @Test public void testNullSafeHashCodeWithShortArray() { int expected = 31 * 7 + 70; expected = 31 * expected + 8; @@ -472,156 +541,187 @@ public final class ObjectUtilsTests extends TestCase { assertEquals(expected, actual); } + @Test public void testNullSafeHashCodeWithShortArrayEqualToNull() { assertEquals(0, ObjectUtils.nullSafeHashCode((short[]) null)); } + @Test public void testNullSafeToStringWithBooleanArray() { boolean[] array = {true, false}; assertEquals("{true, false}", ObjectUtils.nullSafeToString(array)); } + @Test public void testNullSafeToStringWithBooleanArrayBeingEmpty() { boolean[] array = {}; assertEquals("{}", ObjectUtils.nullSafeToString(array)); } + @Test public void testNullSafeToStringWithBooleanArrayEqualToNull() { assertEquals("null", ObjectUtils.nullSafeToString((boolean[]) null)); } + @Test public void testNullSafeToStringWithByteArray() { byte[] array = {5, 8}; assertEquals("{5, 8}", ObjectUtils.nullSafeToString(array)); } + @Test public void testNullSafeToStringWithByteArrayBeingEmpty() { byte[] array = {}; assertEquals("{}", ObjectUtils.nullSafeToString(array)); } + @Test public void testNullSafeToStringWithByteArrayEqualToNull() { assertEquals("null", ObjectUtils.nullSafeToString((byte[]) null)); } + @Test public void testNullSafeToStringWithCharArray() { char[] array = {'A', 'B'}; assertEquals("{'A', 'B'}", ObjectUtils.nullSafeToString(array)); } + @Test public void testNullSafeToStringWithCharArrayBeingEmpty() { char[] array = {}; assertEquals("{}", ObjectUtils.nullSafeToString(array)); } + @Test public void testNullSafeToStringWithCharArrayEqualToNull() { assertEquals("null", ObjectUtils.nullSafeToString((char[]) null)); } + @Test public void testNullSafeToStringWithDoubleArray() { double[] array = {8594.93, 8594023.95}; assertEquals("{8594.93, 8594023.95}", ObjectUtils.nullSafeToString(array)); } + @Test public void testNullSafeToStringWithDoubleArrayBeingEmpty() { double[] array = {}; assertEquals("{}", ObjectUtils.nullSafeToString(array)); } + @Test public void testNullSafeToStringWithDoubleArrayEqualToNull() { assertEquals("null", ObjectUtils.nullSafeToString((double[]) null)); } + @Test public void testNullSafeToStringWithFloatArray() { float[] array = {8.6f, 43.8f}; assertEquals("{8.6, 43.8}", ObjectUtils.nullSafeToString(array)); } + @Test public void testNullSafeToStringWithFloatArrayBeingEmpty() { float[] array = {}; assertEquals("{}", ObjectUtils.nullSafeToString(array)); } + @Test public void testNullSafeToStringWithFloatArrayEqualToNull() { assertEquals("null", ObjectUtils.nullSafeToString((float[]) null)); } + @Test public void testNullSafeToStringWithIntArray() { int[] array = {9, 64}; assertEquals("{9, 64}", ObjectUtils.nullSafeToString(array)); } + @Test public void testNullSafeToStringWithIntArrayBeingEmpty() { int[] array = {}; assertEquals("{}", ObjectUtils.nullSafeToString(array)); } + @Test public void testNullSafeToStringWithIntArrayEqualToNull() { assertEquals("null", ObjectUtils.nullSafeToString((int[]) null)); } + @Test public void testNullSafeToStringWithLongArray() { long[] array = {434l, 23423l}; assertEquals("{434, 23423}", ObjectUtils.nullSafeToString(array)); } + @Test public void testNullSafeToStringWithLongArrayBeingEmpty() { long[] array = {}; assertEquals("{}", ObjectUtils.nullSafeToString(array)); } + @Test public void testNullSafeToStringWithLongArrayEqualToNull() { assertEquals("null", ObjectUtils.nullSafeToString((long[]) null)); } + @Test public void testNullSafeToStringWithPlainOldString() { assertEquals("I shoh love tha taste of mangoes", ObjectUtils.nullSafeToString("I shoh love tha taste of mangoes")); } + @Test public void testNullSafeToStringWithObjectArray() { Object[] array = {"Han", new Long(43)}; assertEquals("{Han, 43}", ObjectUtils.nullSafeToString(array)); } + @Test public void testNullSafeToStringWithObjectArrayBeingEmpty() { Object[] array = {}; assertEquals("{}", ObjectUtils.nullSafeToString(array)); } + @Test public void testNullSafeToStringWithObjectArrayEqualToNull() { assertEquals("null", ObjectUtils.nullSafeToString((Object[]) null)); } + @Test public void testNullSafeToStringWithShortArray() { short[] array = {7, 9}; assertEquals("{7, 9}", ObjectUtils.nullSafeToString(array)); } + @Test public void testNullSafeToStringWithShortArrayBeingEmpty() { short[] array = {}; assertEquals("{}", ObjectUtils.nullSafeToString(array)); } + @Test public void testNullSafeToStringWithShortArrayEqualToNull() { assertEquals("null", ObjectUtils.nullSafeToString((short[]) null)); } + @Test public void testNullSafeToStringWithStringArray() { String[] array = {"Luke", "Anakin"}; assertEquals("{Luke, Anakin}", ObjectUtils.nullSafeToString(array)); } + @Test public void testNullSafeToStringWithStringArrayBeingEmpty() { String[] array = {}; assertEquals("{}", ObjectUtils.nullSafeToString(array)); } + @Test public void testNullSafeToStringWithStringArrayEqualToNull() { assertEquals("null", ObjectUtils.nullSafeToString((String[]) null)); } - enum Tropes { FOO, BAR, baz } - + @Test public void testContainsConstant() { assertThat(ObjectUtils.containsConstant(Tropes.values(), "FOO"), is(true)); assertThat(ObjectUtils.containsConstant(Tropes.values(), "foo"), is(true)); @@ -636,13 +736,15 @@ public final class ObjectUtilsTests extends TestCase { assertThat(ObjectUtils.containsConstant(Tropes.values(), "foo", true), is(false)); } + @Test public void testCaseInsensitiveValueOf() { assertThat(ObjectUtils.caseInsensitiveValueOf(Tropes.values(), "foo"), is(Tropes.FOO)); assertThat(ObjectUtils.caseInsensitiveValueOf(Tropes.values(), "BAR"), is(Tropes.BAR)); try { ObjectUtils.caseInsensitiveValueOf(Tropes.values(), "bogus"); fail("expected IllegalArgumentException"); - } catch (IllegalArgumentException ex) { + } + catch (IllegalArgumentException ex) { assertThat(ex.getMessage(), is("constant [bogus] does not exist in enum type " + "org.springframework.util.ObjectUtilsTests$Tropes")); @@ -655,4 +757,7 @@ public final class ObjectUtilsTests extends TestCase { assertTrue(array.hashCode() != actual); } + + enum Tropes { FOO, BAR, baz } + } diff --git a/spring-core/src/test/java/org/springframework/util/StringUtilsTests.java b/spring-core/src/test/java/org/springframework/util/StringUtilsTests.java index c362a92ed52..be40ac2d7c3 100644 --- a/spring-core/src/test/java/org/springframework/util/StringUtilsTests.java +++ b/spring-core/src/test/java/org/springframework/util/StringUtilsTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2012 the original author or authors. + * 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. @@ -20,29 +20,35 @@ import java.util.Arrays; import java.util.Locale; import java.util.Properties; -import junit.framework.TestCase; +import org.junit.Test; + +import static org.junit.Assert.*; /** * @author Rod Johnson * @author Juergen Hoeller * @author Rick Evans */ -public class StringUtilsTests extends TestCase { +public class StringUtilsTests { + @Test public void testHasTextBlank() throws Exception { String blank = " "; assertEquals(false, StringUtils.hasText(blank)); } + @Test public void testHasTextNullEmpty() throws Exception { assertEquals(false, StringUtils.hasText(null)); assertEquals(false, StringUtils.hasText("")); } + @Test public void testHasTextValid() throws Exception { assertEquals(true, StringUtils.hasText("t")); } + @Test public void testContainsWhitespace() throws Exception { assertFalse(StringUtils.containsWhitespace(null)); assertFalse(StringUtils.containsWhitespace("")); @@ -55,6 +61,7 @@ public class StringUtilsTests extends TestCase { assertTrue(StringUtils.containsWhitespace("a b")); } + @Test public void testTrimWhitespace() throws Exception { assertEquals(null, StringUtils.trimWhitespace(null)); assertEquals("", StringUtils.trimWhitespace("")); @@ -67,6 +74,7 @@ public class StringUtilsTests extends TestCase { assertEquals("a b c", StringUtils.trimWhitespace(" a b c ")); } + @Test public void testTrimAllWhitespace() throws Exception { assertEquals("", StringUtils.trimAllWhitespace("")); assertEquals("", StringUtils.trimAllWhitespace(" ")); @@ -78,6 +86,7 @@ public class StringUtilsTests extends TestCase { assertEquals("abc", StringUtils.trimAllWhitespace(" a b c ")); } + @Test public void testTrimLeadingWhitespace() throws Exception { assertEquals(null, StringUtils.trimLeadingWhitespace(null)); assertEquals("", StringUtils.trimLeadingWhitespace("")); @@ -90,6 +99,7 @@ public class StringUtilsTests extends TestCase { assertEquals("a b c ", StringUtils.trimLeadingWhitespace(" a b c ")); } + @Test public void testTrimTrailingWhitespace() throws Exception { assertEquals(null, StringUtils.trimTrailingWhitespace(null)); assertEquals("", StringUtils.trimTrailingWhitespace("")); @@ -102,6 +112,7 @@ public class StringUtilsTests extends TestCase { assertEquals(" a b c", StringUtils.trimTrailingWhitespace(" a b c ")); } + @Test public void testTrimLeadingCharacter() throws Exception { assertEquals(null, StringUtils.trimLeadingCharacter(null, ' ')); assertEquals("", StringUtils.trimLeadingCharacter("", ' ')); @@ -114,6 +125,7 @@ public class StringUtilsTests extends TestCase { assertEquals("a b c ", StringUtils.trimLeadingCharacter(" a b c ", ' ')); } + @Test public void testTrimTrailingCharacter() throws Exception { assertEquals(null, StringUtils.trimTrailingCharacter(null, ' ')); assertEquals("", StringUtils.trimTrailingCharacter("", ' ')); @@ -126,6 +138,7 @@ public class StringUtilsTests extends TestCase { assertEquals(" a b c", StringUtils.trimTrailingCharacter(" a b c ", ' ')); } + @Test public void testCountOccurrencesOf() { assertTrue("nullx2 = 0", StringUtils.countOccurrencesOf(null, null) == 0); @@ -152,6 +165,7 @@ public class StringUtilsTests extends TestCase { assertTrue("test last", StringUtils.countOccurrencesOf(s, "r") == 2); } + @Test public void testReplace() throws Exception { String inString = "a6AazAaa77abaa"; String oldPattern = "aa"; @@ -174,6 +188,7 @@ public class StringUtilsTests extends TestCase { assertTrue("Replace non matched is equal", s.equals(inString)); } + @Test public void testDelete() throws Exception { String inString = "The quick brown fox jumped over the lazy dog"; @@ -200,6 +215,7 @@ public class StringUtilsTests extends TestCase { assertTrue("Result is unchanged", nochange.equals(inString)); } + @Test public void testDeleteAny() throws Exception { String inString = "Able was I ere I saw Elba"; @@ -213,45 +229,51 @@ public class StringUtilsTests extends TestCase { assertTrue("Result is unchanged", mismatch.equals(inString)); String whitespace = "This is\n\n\n \t a messagy string with whitespace\n"; - assertTrue("Has CR", whitespace.indexOf("\n") != -1); - assertTrue("Has tab", whitespace.indexOf("\t") != -1); - assertTrue("Has sp", whitespace.indexOf(" ") != -1); + assertTrue("Has CR", whitespace.contains("\n")); + assertTrue("Has tab", whitespace.contains("\t")); + assertTrue("Has sp", whitespace.contains(" ")); String cleaned = StringUtils.deleteAny(whitespace, "\n\t "); - assertTrue("Has no CR", cleaned.indexOf("\n") == -1); - assertTrue("Has no tab", cleaned.indexOf("\t") == -1); - assertTrue("Has no sp", cleaned.indexOf(" ") == -1); + assertTrue("Has no CR", !cleaned.contains("\n")); + assertTrue("Has no tab", !cleaned.contains("\t")); + assertTrue("Has no sp", !cleaned.contains(" ")); assertTrue("Still has chars", cleaned.length() > 10); } + @Test public void testQuote() { assertEquals("'myString'", StringUtils.quote("myString")); assertEquals("''", StringUtils.quote("")); assertNull(StringUtils.quote(null)); } + @Test public void testQuoteIfString() { assertEquals("'myString'", StringUtils.quoteIfString("myString")); assertEquals("''", StringUtils.quoteIfString("")); - assertEquals(new Integer(5), StringUtils.quoteIfString(new Integer(5))); + assertEquals(new Integer(5), StringUtils.quoteIfString(5)); assertNull(StringUtils.quoteIfString(null)); } + @Test public void testUnqualify() { String qualified = "i.am.not.unqualified"; assertEquals("unqualified", StringUtils.unqualify(qualified)); } + @Test public void testCapitalize() { String capitalized = "i am not capitalized"; assertEquals("I am not capitalized", StringUtils.capitalize(capitalized)); } + @Test public void testUncapitalize() { String capitalized = "I am capitalized"; assertEquals("i am capitalized", StringUtils.uncapitalize(capitalized)); } + @Test public void testGetFilename() { assertEquals(null, StringUtils.getFilename(null)); assertEquals("", StringUtils.getFilename("")); @@ -263,6 +285,7 @@ public class StringUtilsTests extends TestCase { assertEquals("myfile.txt", StringUtils.getFilename("mypath/myfile.txt")); } + @Test public void testGetFilenameExtension() { assertEquals(null, StringUtils.getFilenameExtension(null)); assertEquals(null, StringUtils.getFilenameExtension("")); @@ -276,6 +299,7 @@ public class StringUtilsTests extends TestCase { assertEquals("txt", StringUtils.getFilenameExtension("/home/user/.m2/settings/myfile.txt")); } + @Test public void testStripFilenameExtension() { assertEquals(null, StringUtils.stripFilenameExtension(null)); assertEquals("", StringUtils.stripFilenameExtension("")); @@ -290,6 +314,7 @@ public class StringUtilsTests extends TestCase { assertEquals("/home/user/.m2/settings/myfile", StringUtils.stripFilenameExtension("/home/user/.m2/settings/myfile.txt")); } + @Test public void testCleanPath() { assertEquals("mypath/myfile", StringUtils.cleanPath("mypath/myfile")); assertEquals("mypath/myfile", StringUtils.cleanPath("mypath\\myfile")); @@ -303,6 +328,7 @@ public class StringUtilsTests extends TestCase { assertEquals("file:///c:/path/to/the%20file.txt", StringUtils.cleanPath("file:///c:/some/../path/to/the%20file.txt")); } + @Test public void testPathEquals() { assertTrue("Must be true for the same strings", StringUtils.pathEquals("/dummy1/dummy2/dummy3", @@ -348,6 +374,7 @@ public class StringUtilsTests extends TestCase { "/dummy1/dummy2/dummy4")); } + @Test public void testConcatenateStringArrays() { String[] input1 = new String[] {"myString2"}; String[] input2 = new String[] {"myString1", "myString2"}; @@ -357,11 +384,12 @@ public class StringUtilsTests extends TestCase { assertEquals("myString1", result[1]); assertEquals("myString2", result[2]); - assertEquals(input1, StringUtils.concatenateStringArrays(input1, null)); - assertEquals(input2, StringUtils.concatenateStringArrays(null, input2)); + assertArrayEquals(input1, StringUtils.concatenateStringArrays(input1, null)); + assertArrayEquals(input2, StringUtils.concatenateStringArrays(null, input2)); assertNull(StringUtils.concatenateStringArrays(null, null)); } + @Test public void testMergeStringArrays() { String[] input1 = new String[] {"myString2"}; String[] input2 = new String[] {"myString1", "myString2"}; @@ -370,11 +398,12 @@ public class StringUtilsTests extends TestCase { assertEquals("myString2", result[0]); assertEquals("myString1", result[1]); - assertEquals(input1, StringUtils.mergeStringArrays(input1, null)); - assertEquals(input2, StringUtils.mergeStringArrays(null, input2)); + assertArrayEquals(input1, StringUtils.mergeStringArrays(input1, null)); + assertArrayEquals(input2, StringUtils.mergeStringArrays(null, input2)); assertNull(StringUtils.mergeStringArrays(null, null)); } + @Test public void testSortStringArray() { String[] input = new String[] {"myString2"}; input = StringUtils.addStringToArray(input, "myString1"); @@ -386,6 +415,7 @@ public class StringUtilsTests extends TestCase { assertEquals("myString2", input[1]); } + @Test public void testRemoveDuplicateStrings() { String[] input = new String[] {"myString2", "myString1", "myString2"}; input = StringUtils.removeDuplicateStrings(input); @@ -393,6 +423,7 @@ public class StringUtilsTests extends TestCase { assertEquals("myString2", input[1]); } + @Test public void testSplitArrayElementsIntoProperties() { String[] input = new String[] {"key1=value1 ", "key2 =\"value2\""}; Properties result = StringUtils.splitArrayElementsIntoProperties(input, "="); @@ -400,6 +431,7 @@ public class StringUtilsTests extends TestCase { assertEquals("\"value2\"", result.getProperty("key2")); } + @Test public void testSplitArrayElementsIntoPropertiesAndDeletedChars() { String[] input = new String[] {"key1=value1 ", "key2 =\"value2\""}; Properties result = StringUtils.splitArrayElementsIntoProperties(input, "=", "\""); @@ -407,6 +439,7 @@ public class StringUtilsTests extends TestCase { assertEquals("value2", result.getProperty("key2")); } + @Test public void testTokenizeToStringArray() { String[] sa = StringUtils.tokenizeToStringArray("a,b , ,c", ","); assertEquals(3, sa.length); @@ -414,6 +447,7 @@ public class StringUtilsTests extends TestCase { sa[0].equals("a") && sa[1].equals("b") && sa[2].equals("c")); } + @Test public void testTokenizeToStringArrayWithNotIgnoreEmptyTokens() { String[] sa = StringUtils.tokenizeToStringArray("a,b , ,c", ",", true, false); assertEquals(4, sa.length); @@ -421,6 +455,7 @@ public class StringUtilsTests extends TestCase { sa[0].equals("a") && sa[1].equals("b") && sa[2].equals("") && sa[3].equals("c")); } + @Test public void testTokenizeToStringArrayWithNotTrimTokens() { String[] sa = StringUtils.tokenizeToStringArray("a,b ,c", ",", false, true); assertEquals(3, sa.length); @@ -428,26 +463,21 @@ public class StringUtilsTests extends TestCase { sa[0].equals("a") && sa[1].equals("b ") && sa[2].equals("c")); } + @Test public void testCommaDelimitedListToStringArrayWithNullProducesEmptyArray() { String[] sa = StringUtils.commaDelimitedListToStringArray(null); assertTrue("String array isn't null with null input", sa != null); assertTrue("String array length == 0 with null input", sa.length == 0); } + @Test public void testCommaDelimitedListToStringArrayWithEmptyStringProducesEmptyArray() { String[] sa = StringUtils.commaDelimitedListToStringArray(""); assertTrue("String array isn't null with null input", sa != null); assertTrue("String array length == 0 with null input", sa.length == 0); } - private void testStringArrayReverseTransformationMatches(String[] sa) { - String[] reverse = - StringUtils.commaDelimitedListToStringArray(StringUtils.arrayToCommaDelimitedString(sa)); - assertEquals("Reverse transformation is equal", - Arrays.asList(sa), - Arrays.asList(reverse)); - } - + @Test public void testDelimitedListToStringArrayWithComma() { String[] sa = StringUtils.delimitedListToStringArray("a,b", ","); assertEquals(2, sa.length); @@ -455,6 +485,7 @@ public class StringUtilsTests extends TestCase { assertEquals("b", sa[1]); } + @Test public void testDelimitedListToStringArrayWithSemicolon() { String[] sa = StringUtils.delimitedListToStringArray("a;b", ";"); assertEquals(2, sa.length); @@ -462,6 +493,7 @@ public class StringUtilsTests extends TestCase { assertEquals("b", sa[1]); } + @Test public void testDelimitedListToStringArrayWithEmptyString() { String[] sa = StringUtils.delimitedListToStringArray("a,b", ""); assertEquals(3, sa.length); @@ -470,28 +502,39 @@ public class StringUtilsTests extends TestCase { assertEquals("b", sa[2]); } + @Test public void testDelimitedListToStringArrayWithNullDelimiter() { String[] sa = StringUtils.delimitedListToStringArray("a,b", null); assertEquals(1, sa.length); assertEquals("a,b", sa[0]); } + @Test public void testCommaDelimitedListToStringArrayMatchWords() { // Could read these from files String[] sa = new String[] {"foo", "bar", "big"}; doTestCommaDelimitedListToStringArrayLegalMatch(sa); - testStringArrayReverseTransformationMatches(sa); + doTestStringArrayReverseTransformationMatches(sa); sa = new String[] {"a", "b", "c"}; doTestCommaDelimitedListToStringArrayLegalMatch(sa); - testStringArrayReverseTransformationMatches(sa); + doTestStringArrayReverseTransformationMatches(sa); // Test same words sa = new String[] {"AA", "AA", "AA", "AA", "AA"}; doTestCommaDelimitedListToStringArrayLegalMatch(sa); - testStringArrayReverseTransformationMatches(sa); + doTestStringArrayReverseTransformationMatches(sa); } + private void doTestStringArrayReverseTransformationMatches(String[] sa) { + String[] reverse = + StringUtils.commaDelimitedListToStringArray(StringUtils.arrayToCommaDelimitedString(sa)); + assertEquals("Reverse transformation is equal", + Arrays.asList(sa), + Arrays.asList(reverse)); + } + + @Test public void testCommaDelimitedListToStringArraySingleString() { // Could read these from files String s = "woeirqupoiewuropqiewuorpqiwueopriquwopeiurqopwieur"; @@ -501,6 +544,7 @@ public class StringUtilsTests extends TestCase { sa[0].equals(s)); } + @Test public void testCommaDelimitedListToStringArrayWithOtherPunctuation() { // Could read these from files String[] sa = new String[] {"xcvwert4456346&*.", "///", ".!", ".", ";"}; @@ -510,6 +554,7 @@ public class StringUtilsTests extends TestCase { /** * We expect to see the empty Strings in the output. */ + @Test public void testCommaDelimitedListToStringArrayEmptyStrings() { // Could read these from files String[] sa = StringUtils.commaDelimitedListToStringArray("a,,b"); @@ -522,19 +567,20 @@ public class StringUtilsTests extends TestCase { } private void doTestCommaDelimitedListToStringArrayLegalMatch(String[] components) { - StringBuffer sbuf = new StringBuffer(); + StringBuilder sb = new StringBuilder(); for (int i = 0; i < components.length; i++) { if (i != 0) { - sbuf.append(","); + sb.append(","); } - sbuf.append(components[i]); + sb.append(components[i]); } - String[] sa = StringUtils.commaDelimitedListToStringArray(sbuf.toString()); + String[] sa = StringUtils.commaDelimitedListToStringArray(sb.toString()); assertTrue("String array isn't null with legal match", sa != null); assertEquals("String array length is correct with legal match", components.length, sa.length); assertTrue("Output equals input", Arrays.equals(sa, components)); } + @Test public void testEndsWithIgnoreCase() { String suffix = "fOo"; assertTrue(StringUtils.endsWithIgnoreCase("foo", suffix)); @@ -551,6 +597,8 @@ public class StringUtilsTests extends TestCase { assertFalse(StringUtils.endsWithIgnoreCase("b", suffix)); } + + @Test public void testParseLocaleStringSunnyDay() throws Exception { Locale expectedLocale = Locale.UK; Locale locale = StringUtils.parseLocaleString(expectedLocale.toString()); @@ -558,19 +606,20 @@ public class StringUtilsTests extends TestCase { assertEquals(expectedLocale, locale); } + @Test public void testParseLocaleStringWithMalformedLocaleString() throws Exception { Locale locale = StringUtils.parseLocaleString("_banjo_on_my_knee"); assertNotNull("When given a malformed Locale string, must not return null.", locale); } + @Test public void testParseLocaleStringWithEmptyLocaleStringYieldsNullLocale() throws Exception { Locale locale = StringUtils.parseLocaleString(""); assertNull("When given an empty Locale string, must return null.", locale); } - /** - * See SPR-8637. - */ + // SPR-8637 + @Test public void testParseLocaleWithMultiSpecialCharactersInVariant() throws Exception { final String variant = "proper-northern"; final String localeString = "en_GB_" + variant; @@ -578,9 +627,8 @@ public class StringUtilsTests extends TestCase { assertEquals("Multi-valued variant portion of the Locale not extracted correctly.", variant, locale.getVariant()); } - /** - * See SPR-3671. - */ + // SPR-3671 + @Test public void testParseLocaleWithMultiValuedVariant() throws Exception { final String variant = "proper_northern"; final String localeString = "en_GB_" + variant; @@ -588,9 +636,8 @@ public class StringUtilsTests extends TestCase { assertEquals("Multi-valued variant portion of the Locale not extracted correctly.", variant, locale.getVariant()); } - /** - * See SPR-3671. - */ + // SPR-3671 + @Test public void testParseLocaleWithMultiValuedVariantUsingSpacesAsSeparators() throws Exception { final String variant = "proper northern"; final String localeString = "en GB " + variant; @@ -598,9 +645,8 @@ public class StringUtilsTests extends TestCase { assertEquals("Multi-valued variant portion of the Locale not extracted correctly.", variant, locale.getVariant()); } - /** - * See SPR-3671. - */ + // SPR-3671 + @Test public void testParseLocaleWithMultiValuedVariantUsingMixtureOfUnderscoresAndSpacesAsSeparators() throws Exception { final String variant = "proper northern"; final String localeString = "en_GB_" + variant; @@ -608,9 +654,8 @@ public class StringUtilsTests extends TestCase { assertEquals("Multi-valued variant portion of the Locale not extracted correctly.", variant, locale.getVariant()); } - /** - * See SPR-3671. - */ + // SPR-3671 + @Test public void testParseLocaleWithMultiValuedVariantUsingSpacesAsSeparatorsWithLotsOfLeadingWhitespace() throws Exception { final String variant = "proper northern"; final String localeString = "en GB " + variant; // lots of whitespace @@ -618,9 +663,8 @@ public class StringUtilsTests extends TestCase { assertEquals("Multi-valued variant portion of the Locale not extracted correctly.", variant, locale.getVariant()); } - /** - * See SPR-3671. - */ + // SPR-3671 + @Test public void testParseLocaleWithMultiValuedVariantUsingUnderscoresAsSeparatorsWithLotsOfLeadingWhitespace() throws Exception { final String variant = "proper_northern"; final String localeString = "en_GB_____" + variant; // lots of underscores @@ -628,9 +672,8 @@ public class StringUtilsTests extends TestCase { assertEquals("Multi-valued variant portion of the Locale not extracted correctly.", variant, locale.getVariant()); } - /** - * See SPR-7779. - */ + // SPR-7779 + @Test public void testParseLocaleWithInvalidCharacters() { try { StringUtils.parseLocaleString("%0D%0AContent-length:30%0D%0A%0D%0A%3Cscript%3Ealert%28123%29%3C/script%3E"); @@ -641,11 +684,20 @@ public class StringUtilsTests extends TestCase { } } - /** - * See SPR-9420. - */ + // SPR-9420 + @Test public void testParseLocaleWithSameLowercaseTokenForLanguageAndCountry() { assertEquals("tr_TR", StringUtils.parseLocaleString("tr_tr").toString()); assertEquals("bg_BG_vnt", StringUtils.parseLocaleString("bg_bg_vnt").toString()); } + + // SPR-11806 + @Test + public void testParseLocaleWithVariantContainingCountryCode() { + String variant = "GBtest"; + String localeString = "en_GB_" + variant; + Locale locale = StringUtils.parseLocaleString(localeString); + assertEquals("Variant containing country code not extracted correctly", variant, locale.getVariant()); + } + }