StringUtils.parseLocaleString parses variant correctly when variant contains country code
This commit also includes a JUnit 4 style revision of StringUtilsTests and ObjectUtilsTests. Issue: SPR-11806
This commit is contained in:
Juergen Hoeller
parent
1285467fe6
commit
295a6aeed6
|
|
@ -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("_")) {
|
||||
|
|
|
|||
|
|
@ -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 }
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
||||
/**
|
||||
* <a href="http://opensource.atlassian.com/projects/spring/browse/SPR-8637">See SPR-8637</a>.
|
||||
*/
|
||||
// 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());
|
||||
}
|
||||
|
||||
/**
|
||||
* <a href="http://opensource.atlassian.com/projects/spring/browse/SPR-3671">See SPR-3671</a>.
|
||||
*/
|
||||
// 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());
|
||||
}
|
||||
|
||||
/**
|
||||
* <a href="http://opensource.atlassian.com/projects/spring/browse/SPR-3671">See SPR-3671</a>.
|
||||
*/
|
||||
// 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());
|
||||
}
|
||||
|
||||
/**
|
||||
* <a href="http://opensource.atlassian.com/projects/spring/browse/SPR-3671">See SPR-3671</a>.
|
||||
*/
|
||||
// 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());
|
||||
}
|
||||
|
||||
/**
|
||||
* <a href="http://opensource.atlassian.com/projects/spring/browse/SPR-3671">See SPR-3671</a>.
|
||||
*/
|
||||
// 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());
|
||||
}
|
||||
|
||||
/**
|
||||
* <a href="http://opensource.atlassian.com/projects/spring/browse/SPR-3671">See SPR-3671</a>.
|
||||
*/
|
||||
// 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());
|
||||
}
|
||||
|
||||
/**
|
||||
* <a href="http://opensource.atlassian.com/projects/spring/browse/SPR-7779">See SPR-7779</a>.
|
||||
*/
|
||||
// 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());
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue