org.springframework.util.StringUtils Test

날짜형식이 입력받을땐 “–“가지고 있으나 디비입력시에는 필요가 없어 제거하는 메소드가 필요해졌다. 정규표현식 이용해서 메소드 정의할려다가 혹시 싶어 스프링 api를 보다보니 역시나 이미 만들어진 유틸 클래스가 존재하였다.

다음은 유틸메소드 TestCase이다. 구글에서 찾은건데 작성자가 Rod Johnson네.. 어디에 TestCase들을 만들어 놓았지? 찾아봐야겠단 생각이 든다.

 

/*

 * Copyright 2002-2006 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.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

 

package org.springframework.util;

 

import java.util.Arrays;

import java.util.Locale;

import java.util.Properties;

 

import junit.framework.TestCase;

 

/**

 * @author Rod Johnson

 * @author Juergen Hoeller

 * @author Rick Evans

 */

public class StringUtilsTests extends TestCase {

     

     

      //hasText 텍스트값이 있는지없는지

      public void testHasTextBlank() throws Exception {

            String blank = "          ";

            assertEquals(false, StringUtils.hasText(blank));

      }

     

      public void testHasTextNullEmpty() throws Exception {

            assertEquals(false, StringUtils.hasText(null));

            assertEquals(false, StringUtils.hasText(""));

      }

 

      public void testHasTextValid() throws Exception {

            assertEquals(true, StringUtils.hasText("t"));

      }

     

      //containsWhitespace 공백이 있는지 없는지

      public void testContainsWhitespace() throws Exception {

            assertFalse(StringUtils.containsWhitespace(null));

            assertFalse(StringUtils.containsWhitespace(""));

            assertFalse(StringUtils.containsWhitespace("a"));

            assertFalse(StringUtils.containsWhitespace("abc"));

            assertTrue(StringUtils.containsWhitespace(" "));

            assertTrue(StringUtils.containsWhitespace(" a"));

            assertTrue(StringUtils.containsWhitespace("abc "));

            assertTrue(StringUtils.containsWhitespace("a b"));

            assertTrue(StringUtils.containsWhitespace("a  b"));

      }

     

      //trimWhitespace 양 사이드 공백을 제거

      public void testTrimWhitespace() throws Exception {

            assertEquals(null, StringUtils.trimWhitespace(null));

            assertEquals("", StringUtils.trimWhitespace(""));

            assertEquals("", StringUtils.trimWhitespace(" "));

            assertEquals("", StringUtils.trimWhitespace("\t"));

            assertEquals("a", StringUtils.trimWhitespace(" a"));

            assertEquals("a", StringUtils.trimWhitespace("a "));

            assertEquals("a", StringUtils.trimWhitespace(" a "));

            assertEquals("a b", StringUtils.trimWhitespace(" a b "));

            assertEquals("a b  c", StringUtils.trimWhitespace(" a b  c "));

      }

 

      //trimLeadingWhitespace 왼쪽 공백 제거 ltrim

      public void testTrimLeadingWhitespace() throws Exception {

            assertEquals(null, StringUtils.trimLeadingWhitespace(null));

            assertEquals("", StringUtils.trimLeadingWhitespace(""));

            assertEquals("", StringUtils.trimLeadingWhitespace(" "));

            assertEquals("", StringUtils.trimLeadingWhitespace("\t"));

            assertEquals("a", StringUtils.trimLeadingWhitespace(" a"));

            assertEquals("a ", StringUtils.trimLeadingWhitespace("a "));

            assertEquals("a ", StringUtils.trimLeadingWhitespace(" a "));

            assertEquals("a b ", StringUtils.trimLeadingWhitespace(" a b "));

            assertEquals("a b  c ", StringUtils.trimLeadingWhitespace(" a b  c "));

      }

 

      //trimTrailingWhitespace 오른쪽 공백 제거 rtrim

      public void testTrimTrailingWhitespace() throws Exception {

            assertEquals(null, StringUtils.trimTrailingWhitespace(null));

            assertEquals("", StringUtils.trimTrailingWhitespace(""));

            assertEquals("", StringUtils.trimTrailingWhitespace(" "));

            assertEquals("", StringUtils.trimTrailingWhitespace("\t"));

            assertEquals("a", StringUtils.trimTrailingWhitespace("a "));

            assertEquals(" a", StringUtils.trimTrailingWhitespace(" a"));

            assertEquals(" a", StringUtils.trimTrailingWhitespace(" a "));

            assertEquals(" a b", StringUtils.trimTrailingWhitespace(" a b "));

            assertEquals(" a b  c", StringUtils.trimTrailingWhitespace(" a b  c "));

      }

 

      //trimAllWhitespace 모든 공백 제거

      public void testTrimAllWhitespace() throws Exception {

            assertEquals("", StringUtils.trimAllWhitespace(""));

            assertEquals("", StringUtils.trimAllWhitespace(" "));

            assertEquals("", StringUtils.trimAllWhitespace("\t"));

            assertEquals("a", StringUtils.trimAllWhitespace(" a"));

            assertEquals("a", StringUtils.trimAllWhitespace("a "));

            assertEquals("a", StringUtils.trimAllWhitespace(" a "));

            assertEquals("ab", StringUtils.trimAllWhitespace(" a b "));

            assertEquals("abc", StringUtils.trimAllWhitespace(" a b  c "));

      }

 

      //countOccurrencesOf 해당문자가 몇번 나오는지

      public void testCountOccurrencesOf() {

            assertTrue("nullx2 = 0",

                        StringUtils.countOccurrencesOf(null, null) == 0);

            assertTrue("null string = 0",

                        StringUtils.countOccurrencesOf("s", null) == 0);

            assertTrue("null substring = 0",

                        StringUtils.countOccurrencesOf(null, "s") == 0);

            String s = "erowoiueoiur";

            assertTrue("not found = 0",

                        StringUtils.countOccurrencesOf(s, "WERWER") == 0);

            assertTrue("not found char = 0",

                        StringUtils.countOccurrencesOf(s, "x") == 0);

            assertTrue("not found ws = 0",

                        StringUtils.countOccurrencesOf(s, " ") == 0);

            assertTrue("not found empty string = 0",

                        StringUtils.countOccurrencesOf(s, "") == 0);

            assertTrue("found char=2", StringUtils.countOccurrencesOf(s, "e") == 2);

            assertTrue("found substring=2",

                        StringUtils.countOccurrencesOf(s, "oi") == 2);

            assertTrue("found substring=2",

                        StringUtils.countOccurrencesOf(s, "oiu") == 2);

            assertTrue("found substring=3",

                        StringUtils.countOccurrencesOf(s, "oiur") == 1);

            assertTrue("test last", StringUtils.countOccurrencesOf(s, "r") == 2);

      }

 

      //replace 문자 치환하기

      public void testReplace() throws Exception {

            String inString = "a6AazAaa77abaa";

            String oldPattern = "aa";

            String newPattern = "foo";

 

            // Simple replace

            String s = StringUtils.replace(inString, oldPattern, newPattern);

            assertTrue("Replace 1 worked", s.equals("a6AazAfoo77abfoo"));

 

            // Non match: no change

            s = StringUtils.replace(inString, "qwoeiruqopwieurpoqwieur", newPattern);

            assertTrue("Replace non matched is equal", s.equals(inString));

 

            // Null new pattern: should ignore

            s = StringUtils.replace(inString, oldPattern, null);

            assertTrue("Replace non matched is equal", s.equals(inString));

 

            // Null old pattern: should ignore

            s = StringUtils.replace(inString, null, newPattern);

            assertTrue("Replace non matched is equal", s.equals(inString));

      }

 

      //delete 문자 삭제하기(비교문자전체가 일치)

      public void testDelete() throws Exception {

            String inString = "The quick brown fox jumped over the lazy dog";

 

            String noThe = StringUtils.delete(inString, "the");

            assertTrue("Result has no the [" + noThe + "]",

                        noThe.equals("The quick brown fox jumped over  lazy dog"));

 

            String nohe = StringUtils.delete(inString, "he");

            assertTrue("Result has no he [" + nohe + "]",

                        nohe.equals("T quick brown fox jumped over t lazy dog"));

 

            String nosp = StringUtils.delete(inString, " ");

            assertTrue("Result has no spaces",

                        nosp.equals("Thequickbrownfoxjumpedoverthelazydog"));

 

            String killEnd = StringUtils.delete(inString, "dog");

            assertTrue("Result has no dog",

                        killEnd.equals("The quick brown fox jumped over the lazy "));

 

            String mismatch = StringUtils.delete(inString, "dxxcxcxog");

            assertTrue("Result is unchanged", mismatch.equals(inString));

      }

     

      //deleteAny 문자 삭제하기(비교문자에 있는건 모두)

      public void testDeleteAny() throws Exception {

            String inString = "Able was I ere I saw Elba";

 

            String res = StringUtils.deleteAny(inString, "I");

            assertTrue("Result has no Is [" + res + "]",

                        res.equals("Able was  ere  saw Elba"));

 

            res = StringUtils.deleteAny(inString, "AeEba!");

            assertTrue("Result has no Is [" + res + "]",

                        res.equals("l ws I r I sw l"));

 

            String mismatch = StringUtils.deleteAny(inString, "#@$#$^");

            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);

            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("Still has chars", cleaned.length() > 10);

      }

 

      //quote 작은따옴표

      public void testQuote() {

            assertEquals("'myString'", StringUtils.quote("myString"));

            assertEquals("''", StringUtils.quote(""));

            assertNull(StringUtils.quote(null));

      }

     

      //quoteIfString 문자일때만 작은따옴표

      public void testQuoteIfString() {

            assertEquals("'myString'", StringUtils.quoteIfString("myString"));

            assertEquals("''", StringUtils.quoteIfString(""));

            assertEquals(new Integer(5), StringUtils.quoteIfString(new Integer(5)));

            assertNull(StringUtils.quoteIfString(null));

      }

 

      //unqualify 전체이름 무시(.으로 구분 제일 마지막만)

      public void testUnqualify() {

            String qualified = "i.am.not.unqualified";

            assertEquals("unqualified", StringUtils.unqualify(qualified));

      }

     

      //capitalize 첫문자 대문자

      public void testCapitalize() {

            String capitalized = "i am not capitalized";

            assertEquals("I am not capitalized", StringUtils.capitalize(capitalized));

      }

 

      //uncapitalize 첫문자 소문자

      public void testUncapitalize() {

            String capitalized = "I am capitalized";

            assertEquals("i am capitalized", StringUtils.uncapitalize(capitalized));

      }

     

      //getFilename 패스에서 파일이름 얻기

      public void testGetFilename() {

            assertEquals(null, StringUtils.getFilename(null));

            assertEquals("", StringUtils.getFilename(""));

            assertEquals("myfile", StringUtils.getFilename("myfile"));

            assertEquals("myfile", StringUtils.getFilename("mypath/myfile"));

            assertEquals("myfile.", StringUtils.getFilename("myfile."));

            assertEquals("myfile.", StringUtils.getFilename("mypath/myfile."));

            assertEquals("myfile.txt", StringUtils.getFilename("myfile.txt"));

            assertEquals("myfile.txt", StringUtils.getFilename("mypath/myfile.txt"));

      }

 

      //getFilenameExtension 패스에서 파일확장자 얻기

      public void testGetFilenameExtension() {

            assertEquals(null, StringUtils.getFilenameExtension(null));

            assertEquals(null, StringUtils.getFilenameExtension(""));

            assertEquals(null, StringUtils.getFilenameExtension("myfile"));

            assertEquals(null, StringUtils.getFilenameExtension("myPath/myfile"));

            assertEquals("", StringUtils.getFilenameExtension("myfile."));

            assertEquals("", StringUtils.getFilenameExtension("myPath/myfile."));

            assertEquals("txt", StringUtils.getFilenameExtension("myfile.txt"));

            assertEquals("txt", StringUtils.getFilenameExtension("mypath/myfile.txt"));

      }

 

      //stripFilenameExtension 패스에서 경로와 파일이름 얻기

      public void testStripFilenameExtension() {

            assertEquals(null, StringUtils.stripFilenameExtension(null));

            assertEquals("", StringUtils.stripFilenameExtension(""));

            assertEquals("myfile", StringUtils.stripFilenameExtension("myfile"));

            assertEquals("mypath/myfile", StringUtils.stripFilenameExtension("mypath/myfile"));

            assertEquals("myfile", StringUtils.stripFilenameExtension("myfile."));

            assertEquals("mypath/myfile", StringUtils.stripFilenameExtension("mypath/myfile."));

            assertEquals("myfile", StringUtils.stripFilenameExtension("myfile.txt"));

            assertEquals("mypath/myfile", StringUtils.stripFilenameExtension("mypath/myfile.txt"));

      }

     

      //cleanPath 패스 정리

      public void testCleanPath() {

            assertEquals("mypath/myfile", StringUtils.cleanPath("mypath/myfile"));

            assertEquals("mypath/myfile", StringUtils.cleanPath("mypath\\myfile"));

            assertEquals("mypath/myfile", StringUtils.cleanPath("mypath/../mypath/myfile"));

            assertEquals("mypath/myfile", StringUtils.cleanPath("mypath/myfile/../../mypath/myfile"));

            assertEquals("../mypath/myfile", StringUtils.cleanPath("../mypath/myfile"));

            assertEquals("../mypath/myfile", StringUtils.cleanPath("../mypath/../mypath/myfile"));

            assertEquals("../mypath/myfile", StringUtils.cleanPath("mypath/../../mypath/myfile"));

      }

 

      //pathEquals 패스가 같은지 비교

      public void testPathEquals() {

            assertTrue("Must be true for the same strings",

                        StringUtils.pathEquals("/dummy1/dummy2/dummy3",

                                    "/dummy1/dummy2/dummy3"));

            assertTrue("Must be true for the same win strings",

                        StringUtils.pathEquals("C:\\dummy1\\dummy2\\dummy3",

                                    "C:\\dummy1\\dummy2\\dummy3"));

            assertTrue("Must be true for one top path on 1",

                        StringUtils.pathEquals("/dummy1/bin/../dummy2/dummy3",

                                    "/dummy1/dummy2/dummy3"));

            assertTrue("Must be true for one win top path on 2",

                        StringUtils.pathEquals("C:\\dummy1\\dummy2\\dummy3",

                                    "C:\\dummy1\\bin\\..\\dummy2\\dummy3"));

            assertTrue("Must be true for two top paths on 1",

                        StringUtils.pathEquals("/dummy1/bin/../dummy2/bin/../dummy3",

                                    "/dummy1/dummy2/dummy3"));

            assertTrue("Must be true for two win top paths on 2",

                        StringUtils.pathEquals("C:\\dummy1\\dummy2\\dummy3",

                                    "C:\\dummy1\\bin\\..\\dummy2\\bin\\..\\dummy3"));

            assertTrue("Must be true for double top paths on 1",

                        StringUtils.pathEquals("/dummy1/bin/tmp/../../dummy2/dummy3",

                                    "/dummy1/dummy2/dummy3"));

            assertTrue("Must be true for double top paths on 2 with similarity",

                        StringUtils.pathEquals("/dummy1/dummy2/dummy3",

                                    "/dummy1/dum/dum/../../dummy2/dummy3"));

            assertTrue("Must be true for current paths",

                        StringUtils.pathEquals("./dummy1/dummy2/dummy3",

                                    "dummy1/dum/./dum/../../dummy2/dummy3"));

            assertFalse("Must be false for relative/absolute paths",

                        StringUtils.pathEquals("./dummy1/dummy2/dummy3",

                                    "/dummy1/dum/./dum/../../dummy2/dummy3"));

            assertFalse("Must be false for different strings",

                        StringUtils.pathEquals("/dummy1/dummy2/dummy3",

                                    "/dummy1/dummy4/dummy3"));

            assertFalse("Must be false for one false path on 1",

                        StringUtils.pathEquals("/dummy1/bin/tmp/../dummy2/dummy3",

                                    "/dummy1/dummy2/dummy3"));

            assertFalse("Must be false for one false win top path on 2",

                        StringUtils.pathEquals("C:\\dummy1\\dummy2\\dummy3",

                                    "C:\\dummy1\\bin\\tmp\\..\\dummy2\\dummy3"));

            assertFalse("Must be false for top path on 1 + difference",

                        StringUtils.pathEquals("/dummy1/bin/../dummy2/dummy3",

                                    "/dummy1/dummy2/dummy4"));

      }

 

      //concatenateStringArrays 배열을 합쳐서 하나의 배열로(중복값 유지)

      public void testConcatenateStringArrays() {

            String[] input1 = new String[] {"myString2"};

            String[] input2 = new String[] {"myString1", "myString2"};

            String[] result = StringUtils.concatenateStringArrays(input1, input2);

            assertEquals(3, result.length);

            assertEquals("myString2", result[0]);

            assertEquals("myString1", result[1]);

            assertEquals("myString2", result[2]);

 

            assertEquals(input1, StringUtils.concatenateStringArrays(input1, null));

            assertEquals(input2, StringUtils.concatenateStringArrays(null, input2));

            assertNull(StringUtils.concatenateStringArrays(null, null));

      }

 

      //mergeStringArrays 배열을 합쳐 하나의 배열로(중복값 제거)

      public void testMergeStringArrays() {

            String[] input1 = new String[] {"myString2"};

            String[] input2 = new String[] {"myString1", "myString2"};

            String[] result = StringUtils.mergeStringArrays(input1, input2);

            assertEquals(2, result.length);

            assertEquals("myString2", result[0]);

            assertEquals("myString1", result[1]);

 

            assertEquals(input1, StringUtils.mergeStringArrays(input1, null));

            assertEquals(input2, StringUtils.mergeStringArrays(null, input2));

            assertNull(StringUtils.mergeStringArrays(null, null));

      }

 

      //addStringToArray 배열에 값 추가

      public void testSortStringArray() {

            String[] input = new String[] {"myString2"};

            input = StringUtils.addStringToArray(input, "myString1");

            assertEquals("myString2", input[0]);

            assertEquals("myString1", input[1]);

 

            StringUtils.sortStringArray(input);

            assertEquals("myString1", input[0]);

            assertEquals("myString2", input[1]);

      }

 

      //removeDuplicateStrings 배열 중복값 제거

      public void testRemoveDuplicateStrings() {

            String[] input = new String[] {"myString2", "myString1", "myString2"};

            input = StringUtils.removeDuplicateStrings(input);

            assertEquals("myString1", input[0]);

            assertEquals("myString2", input[1]);

      }

 

      //splitArrayElementsIntoProperties 배열을 프로퍼티로

      public void testSplitArrayElementsIntoProperties() {

            String[] input = new String[] {"key1=value1 ", "key2 =\"value2\""};

            Properties result = StringUtils.splitArrayElementsIntoProperties(input, "=");

            assertEquals("value1", result.getProperty("key1"));

            assertEquals("\"value2\"", result.getProperty("key2"));

      }

 

      public void testSplitArrayElementsIntoPropertiesAndDeletedChars() {

            String[] input = new String[] {"key1=value1 ", "key2 =\"value2\""};

            Properties result = StringUtils.splitArrayElementsIntoProperties(input, "=", "\"");

            assertEquals("value1", result.getProperty("key1"));

            assertEquals("value2", result.getProperty("key2"));

      }

 

      //tokenizeToStringArray 토큰나이즈값을 배열로(문자열, 구분자, 공백제거여부, 빈값제거여부)

      public void testTokenizeToStringArray() {

            String[] sa = StringUtils.tokenizeToStringArray("a,b , ,c", ",");

            assertEquals(3, sa.length);

            assertTrue("components are correct",

                        sa[0].equals("a") && sa[1].equals("b") && sa[2].equals("c"));

      }

 

      public void testTokenizeToStringArrayWithNotIgnoreEmptyTokens() {

            String[] sa = StringUtils.tokenizeToStringArray("a,b , ,c", ",", true, false);

            assertEquals(4, sa.length);

            assertTrue("components are correct",

                        sa[0].equals("a") && sa[1].equals("b") && sa[2].equals("") && sa[3].equals("c"));

      }

 

      public void testTokenizeToStringArrayWithNotTrimTokens() {

            String[] sa = StringUtils.tokenizeToStringArray("a,b ,c", ",", false, true);

            assertEquals(3, sa.length);

            assertTrue("components are correct",

                        sa[0].equals("a") && sa[1].equals("b ") && sa[2].equals("c"));

      }

     

      //commaDelimitedListToStringArray CVS형식을 배열로

      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);

      }

 

      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));

      }

     

      //delimitedListToStringArray 구분자로 구성된 문자열을 배열로

      public void testDelimitedListToStringArrayWithComma() {

            String[] sa = StringUtils.delimitedListToStringArray("a,b", ",");

            assertEquals(2, sa.length);

            assertEquals("a", sa[0]);

            assertEquals("b", sa[1]);

      }

 

      public void testDelimitedListToStringArrayWithSemicolon() {

            String[] sa = StringUtils.delimitedListToStringArray("a;b", ";");

            assertEquals(2, sa.length);

            assertEquals("a", sa[0]);

            assertEquals("b", sa[1]);

      }

 

      public void testDelimitedListToStringArrayWithEmptyString() {

            String[] sa = StringUtils.delimitedListToStringArray("a,b", "");

            assertEquals(3, sa.length);

            assertEquals("a", sa[0]);

            assertEquals(",", sa[1]);

            assertEquals("b", sa[2]);

      }

 

      public void testDelimitedListToStringArrayWithNullDelimiter() {

            String[] sa = StringUtils.delimitedListToStringArray("a,b", null);

            assertEquals(1, sa.length);

            assertEquals("a,b", sa[0]);

      }

 

      public void testCommaDelimitedListToStringArrayMatchWords() {

            // Could read these from files

            String[] sa = new String[] {"foo", "bar", "big"};

            doTestCommaDelimitedListToStringArrayLegalMatch(sa);

            testStringArrayReverseTransformationMatches(sa);

 

            sa = new String[] {"a", "b", "c"};

            doTestCommaDelimitedListToStringArrayLegalMatch(sa);

            testStringArrayReverseTransformationMatches(sa);

 

            // Test same words

            sa = new String[] {"AA", "AA", "AA", "AA", "AA"};

            doTestCommaDelimitedListToStringArrayLegalMatch(sa);

            testStringArrayReverseTransformationMatches(sa);

      }

 

      public void testCommaDelimitedListToStringArraySingleString() {

            // Could read these from files

            String s = "woeirqupoiewuropqiewuorpqiwueopriquwopeiurqopwieur";

            String[] sa = StringUtils.commaDelimitedListToStringArray(s);

            assertTrue("Found one String with no delimiters", sa.length == 1);

            assertTrue("Single array entry matches input String with no delimiters",

                        sa[0].equals(s));

      }

 

      public void testCommaDelimitedListToStringArrayWithOtherPunctuation() {

            // Could read these from files

            String[] sa = new String[] {"xcvwert4456346&*.", "///", ".!", ".", ";"};

            doTestCommaDelimitedListToStringArrayLegalMatch(sa);

      }

 

      /**

       * We expect to see the empty Strings in the output.

       */

      public void testCommaDelimitedListToStringArrayEmptyStrings() {

            // Could read these from files

            String[] sa = StringUtils.commaDelimitedListToStringArray("a,,b");

            assertEquals("a,,b produces array length 3", 3, sa.length);

            assertTrue("components are correct",

                        sa[0].equals("a") && sa[1].equals("") && sa[2].equals("b"));

 

            sa = new String[] {"", "", "a", ""};

            doTestCommaDelimitedListToStringArrayLegalMatch(sa);

      }

 

      private void doTestCommaDelimitedListToStringArrayLegalMatch(String[] components) {

            StringBuffer sbuf = new StringBuffer();

            for (int i = 0; i < components.length; i++) {

                  if (i != 0) {

                        sbuf.append(",");

                  }

                  sbuf.append(components[i]);

            }

            String[] sa = StringUtils.commaDelimitedListToStringArray(sbuf.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));

      }

     

      //endsWithIgnoreCase 입력받은 접미어로 끝나는지(대소문자 무시)<-->startsWithIgnoreCase(str, prefix)

      public void testEndsWithIgnoreCase() {

            String suffix = "fOo";

            assertTrue(StringUtils.endsWithIgnoreCase("foo", suffix));

            assertTrue(StringUtils.endsWithIgnoreCase("Foo", suffix));

            assertTrue(StringUtils.endsWithIgnoreCase("barfoo", suffix));

            assertTrue(StringUtils.endsWithIgnoreCase("barbarfoo", suffix));

            assertTrue(StringUtils.endsWithIgnoreCase("barFoo", suffix));

            assertTrue(StringUtils.endsWithIgnoreCase("barBarFoo", suffix));

            assertTrue(StringUtils.endsWithIgnoreCase("barfoO", suffix));

            assertTrue(StringUtils.endsWithIgnoreCase("barFOO", suffix));

            assertTrue(StringUtils.endsWithIgnoreCase("barfOo", suffix));

            assertFalse(StringUtils.endsWithIgnoreCase(null, suffix));

            assertFalse(StringUtils.endsWithIgnoreCase("barfOo", null));

            assertFalse(StringUtils.endsWithIgnoreCase("b", suffix));

      }

     

      //parseLocaleString 로케일 파싱

      public void testParseLocaleStringSunnyDay() throws Exception {

            Locale expectedLocale = Locale.UK;

            Locale locale = StringUtils.parseLocaleString(expectedLocale.toString());

            assertNotNull("When given a bona-fide Locale string, must not return null.", locale);

            assertEquals(expectedLocale, locale);

      }

 

      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);

      }

 

      public void testParseLocaleStringWithEmptyLocaleStringYieldsNullLocale() throws Exception {

            Locale locale = StringUtils.parseLocaleString("");

            assertNull("When given an empty Locale string, must return null.", locale);

      }

 

}

다음은 JUnit을 이용해 Eclipse에서 테스트 하는 스크린샷..