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

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("_")) {

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 }
+
 }

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 CR", whitespace.contains("\n"));
-		assertTrue("Has tab", whitespace.indexOf("\t") != -1);
+		assertTrue("Has tab", whitespace.contains("\t"));
-		assertTrue("Has  sp", whitespace.indexOf(" ") != -1);
+		assertTrue("Has  sp", whitespace.contains(" "));
 		String cleaned = StringUtils.deleteAny(whitespace, "\n\t ");
-		assertTrue("Has no CR", cleaned.indexOf("\n") == -1);
+		assertTrue("Has no CR", !cleaned.contains("\n"));
-		assertTrue("Has no tab", cleaned.indexOf("\t") == -1);
+		assertTrue("Has no tab", !cleaned.contains("\t"));
-		assertTrue("Has no sp", cleaned.indexOf(" ") == -1);
+		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));
+		assertArrayEquals(input1, StringUtils.concatenateStringArrays(input1, null));
-		assertEquals(input2, StringUtils.concatenateStringArrays(null, input2));
+		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));
+		assertArrayEquals(input1, StringUtils.mergeStringArrays(input1, null));
-		assertEquals(input2, StringUtils.mergeStringArrays(null, input2));
+		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) {
+	@Test
-		String[] reverse =
-				StringUtils.commaDelimitedListToStringArray(StringUtils.arrayToCommaDelimitedString(sa));
-		assertEquals("Reverse transformation is equal",
-				Arrays.asList(sa),
-				Arrays.asList(reverse));
-	}
-
 	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);
 	}
 
-	/**
+	// SPR-8637
-	 * <a href="http://opensource.atlassian.com/projects/spring/browse/SPR-8637">See SPR-8637</a>.
+	@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());
 	}
 
-	/**
+	// SPR-3671
-	 * <a href="http://opensource.atlassian.com/projects/spring/browse/SPR-3671">See SPR-3671</a>.
+	@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());
 	}
 
-	/**
+	// SPR-3671
-	 * <a href="http://opensource.atlassian.com/projects/spring/browse/SPR-3671">See SPR-3671</a>.
+	@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());
 	}
 
-	/**
+	// SPR-3671
-	 * <a href="http://opensource.atlassian.com/projects/spring/browse/SPR-3671">See SPR-3671</a>.
+	@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());
 	}
 
-	/**
+	// SPR-3671
-	 * <a href="http://opensource.atlassian.com/projects/spring/browse/SPR-3671">See SPR-3671</a>.
+	@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());
 	}
 
-	/**
+	// SPR-3671
-	 * <a href="http://opensource.atlassian.com/projects/spring/browse/SPR-3671">See SPR-3671</a>.
+	@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());
 	}
 
-	/**
+	// SPR-7779
-	 * <a href="http://opensource.atlassian.com/projects/spring/browse/SPR-7779">See SPR-7779</a>.
+	@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 {
 		}
 	}
 
-	/**
+	// SPR-9420
-	 * See 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());
+	}
+
 }