| package org.apache.maven.shared.utils; |
| |
| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you 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. |
| */ |
| |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.Map; |
| |
| import org.junit.Assert; |
| import org.junit.Rule; |
| import org.junit.Test; |
| import org.junit.rules.TemporaryFolder; |
| |
| import static org.hamcrest.CoreMatchers.is; |
| import static org.hamcrest.CoreMatchers.nullValue; |
| |
| /** |
| * Test the {@link StringUtils} class. |
| * |
| * We don't need to test this |
| * @author <a href="mailto:struberg@yahoo.de">Mark Struberg</a> |
| */ |
| public class StringUtilsTest |
| extends Assert |
| { |
| |
| @Rule |
| public TemporaryFolder tempFolder = new TemporaryFolder(); |
| |
| |
| @Test( expected = NullPointerException.class ) |
| public void testAbbreviate_NPE() |
| { |
| assertThat( StringUtils.abbreviate( null, 10 ) |
| , nullValue() ); |
| } |
| |
| @Test( expected = IllegalArgumentException.class ) |
| public void testAbbreviate_MinLength() |
| { |
| assertThat( StringUtils.abbreviate( "This is a longtext", 3 ) |
| , is( "T" ) ); |
| } |
| |
| @Test |
| public void testAbbreviate() |
| { |
| assertThat( StringUtils.abbreviate( "This is a longtext", 10 ) |
| , is( "This is..." ) ); |
| |
| assertThat( StringUtils.abbreviate( "This is a longtext", 50 ) |
| , is( "This is a longtext" ) ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testAbbreviate_Offset_NPE() |
| { |
| assertThat( StringUtils.abbreviate( null, 10, 20 ) |
| , nullValue() ); |
| } |
| |
| @Test( expected = IllegalArgumentException.class ) |
| public void testAbbreviate_Offset_MinLength() |
| { |
| assertThat( StringUtils.abbreviate( "This is a longtext", 10, 3 ) |
| , is( "T" ) ); |
| } |
| |
| @Test |
| public void testAbbreviate_Offset() |
| { |
| assertThat( StringUtils.abbreviate( "This is a longtext", 5, 10 ) |
| , is( "...is a..." ) ); |
| |
| assertThat( StringUtils.abbreviate( "This is a longtext", 10, 20 ) |
| , is( "This is a longtext" ) ); |
| |
| assertThat( StringUtils.abbreviate( "This is a longtext", 50, 20 ) |
| , is( "This is a longtext" ) ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testAddAndDeHump_NPE() |
| { |
| StringUtils.addAndDeHump( null ); |
| } |
| |
| @Test |
| public void testAddAndDeHump() |
| { |
| assertThat( StringUtils.addAndDeHump( "lalala" ) |
| , is( "lalala" ) ); |
| |
| assertThat( StringUtils.addAndDeHump( "LaLaLa" ) |
| , is( "la-la-la" ) ); |
| |
| assertThat( StringUtils.addAndDeHump( "ALLUPPER" ) |
| , is( "a-l-l-u-p-p-e-r" ) ); |
| |
| } |
| |
| @Test |
| public void testCapitalise() |
| { |
| assertThat( StringUtils.capitalise( null ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.capitalise( "startBig" ) |
| , is( "StartBig" ) ); |
| } |
| |
| @Test |
| public void testCapitaliseAllWords() |
| { |
| assertThat( StringUtils.capitaliseAllWords( null ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.capitaliseAllWords( "start all big" ) |
| , is( "Start All Big" ) ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testCapitalizeFirstLetter_NPE() |
| { |
| assertThat( StringUtils.capitalizeFirstLetter( null ) |
| , nullValue() ); |
| } |
| |
| @Test |
| public void testCapitalizeFirstLetter() |
| { |
| assertThat( StringUtils.capitalizeFirstLetter( "Dings" ) |
| , is( "Dings" ) ); |
| |
| assertThat( StringUtils.capitalizeFirstLetter( " dings" ) |
| , is( " dings" ) ); |
| |
| assertThat( StringUtils.capitalizeFirstLetter( "start all big" ) |
| , is( "Start all big" ) ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testCenter_NPE() |
| { |
| StringUtils.center( null, 20 ); |
| } |
| |
| @Test |
| public void testCenter() |
| { |
| assertThat( StringUtils.center( "centerMe", 20 ) |
| , is( " centerMe " ) ); |
| |
| assertThat( StringUtils.center( "centerMe", 4 ) |
| , is( "centerMe" ) ); |
| |
| assertThat( StringUtils.center( " centerMe", 20 ) |
| , is( " centerMe " ) ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testCenter_Delim_NPE() |
| { |
| StringUtils.center( null, 20, "*" ); |
| } |
| |
| @Test |
| public void testCenter_Delim() |
| { |
| assertThat( StringUtils.center( "centerMe", 20, "*" ) |
| , is( "******centerMe******" ) ); |
| |
| assertThat( StringUtils.center( "centerMe", 4, "*" ) |
| , is( "centerMe" ) ); |
| |
| assertThat( StringUtils.center( " centerMe", 20, "*" ) |
| , is( "** centerMe**" ) ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testChomp_NPE() |
| { |
| StringUtils.chomp( null ); |
| } |
| |
| @Test |
| public void testChomp() |
| { |
| assertThat( StringUtils.chomp( "dings" ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.chomp( "dings\n" ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.chomp( "dings\nbums" ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.chomp( "dings\nbums\ndongs" ) |
| , is( "dings\nbums" ) ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testChomp_Delim_NPE() |
| { |
| StringUtils.chomp( null, "+" ); |
| } |
| |
| @Test |
| public void testChomp_Delim() |
| { |
| assertThat( StringUtils.chomp( "dings", "+" ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.chomp( "dings+", "+" ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.chomp( "dings+bums", "+" ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.chomp( "dings+bums+dongs", "+" ) |
| , is( "dings+bums" ) ); |
| } |
| |
| |
| @Test( expected = NullPointerException.class ) |
| public void testChompLast_NPE() |
| { |
| StringUtils.chompLast( null ); |
| } |
| |
| @Test |
| public void testChompLast() |
| { |
| assertThat( StringUtils.chompLast( "dings" ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.chompLast( "\n" ) |
| , is( "" ) ); |
| |
| assertThat( StringUtils.chompLast( "dings\n" ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.chompLast( "dings\nbums" ) |
| , is( "dings\nbums" ) ); |
| |
| assertThat( StringUtils.chompLast( "dings\nbums\ndongs\n" ) |
| , is( "dings\nbums\ndongs" ) ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testChompLast_Delim_NPE() |
| { |
| StringUtils.chompLast( null, "+" ); |
| } |
| |
| @Test |
| public void testChompLast_Delim() |
| { |
| assertThat( StringUtils.chompLast( "dings", "+" ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.chompLast( "+", "+" ) |
| , is( "" ) ); |
| |
| assertThat( StringUtils.chompLast( "dings+", "+" ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.chompLast( "dings+bums", "+" ) |
| , is( "dings+bums" ) ); |
| |
| assertThat( StringUtils.chompLast( "dings+bums+dongs+", "+" ) |
| , is( "dings+bums+dongs" ) ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testChop_NPE() |
| { |
| StringUtils.chop( null ); |
| } |
| |
| @Test |
| public void testChop() |
| { |
| assertThat( StringUtils.chop( "dings" ) |
| , is( "ding" ) ); |
| |
| assertThat( StringUtils.chop( "x" ) |
| , is( "" ) ); |
| |
| assertThat( StringUtils.chop( "dings\n" ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.chop( "dings\r\n" ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.chop( "dings\n\r" ) |
| , is( "dings\n" ) ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testChopNewline_NPE() |
| { |
| StringUtils.chopNewline( null ); |
| } |
| |
| @Test |
| public void testChopNewline() |
| { |
| assertThat( StringUtils.chopNewline( "dings" ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.chopNewline( "x" ) |
| , is( "x" ) ); |
| |
| |
| assertThat( StringUtils.chopNewline( "dings\n" ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.chopNewline( "dings\r\n" ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.chopNewline( "dings\n\r" ) |
| , is( "dings\n\r" ) ); |
| } |
| |
| |
| @Test |
| public void testClean() |
| { |
| assertThat( StringUtils.clean( null ) |
| , is( "" ) ); |
| |
| assertThat( StringUtils.clean( " " ) |
| , is( "" ) ); |
| |
| assertThat( StringUtils.clean( " c " ) |
| , is( "c" ) ); |
| |
| assertThat( StringUtils.clean( " dings \n " ) |
| , is( "dings" ) ); |
| } |
| |
| |
| @Test( expected = NullPointerException.class ) |
| public void testConcatenate_NPE() |
| { |
| StringUtils.concatenate( null ); |
| } |
| |
| @Test |
| public void testConcatenate() |
| { |
| assertThat( StringUtils.concatenate( new String[0] ) |
| , is( "" ) ); |
| |
| assertThat( StringUtils.concatenate( new String[]{ "x" } ) |
| , is( "x" ) ); |
| |
| assertThat( StringUtils.concatenate( new String[]{ "x", "y", "z" } ) |
| , is( "xyz" ) ); |
| } |
| |
| @Test |
| public void testContains_String() |
| { |
| assertThat( StringUtils.contains( null, null ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.contains( null, "string" ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.contains( "string", null ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.contains( "string", "" ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.contains( "string", "in" ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.contains( "string", "IN" ) |
| , is( false ) ); |
| } |
| |
| @Test |
| public void testContains_Char() |
| { |
| assertThat( StringUtils.contains( null, 'c' ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.contains( "string", "c" ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.contains( "string", "" ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.contains( "string", "r" ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.contains( "string", "R" ) |
| , is( false ) ); |
| |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testCountMatches_NPE() |
| { |
| StringUtils.countMatches( null, null ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testCountMatches_NPE2() |
| { |
| StringUtils.countMatches( "this is it", null ); |
| } |
| |
| @Test |
| public void testCountMatches() |
| { |
| assertThat( StringUtils.countMatches( null, "is" ) |
| , is( 0 ) ); |
| |
| assertThat( StringUtils.countMatches( "this is it", "is" ) |
| , is( 2 ) ); |
| |
| assertThat( StringUtils.countMatches( "this is it", "notincluded" ) |
| , is( 0 ) ); |
| } |
| |
| @Test |
| public void testDefaultString() |
| { |
| assertThat( StringUtils.defaultString( null ) |
| , is( "" ) ); |
| |
| assertThat( StringUtils.defaultString( "dings" ) |
| , is( "dings" ) ); |
| } |
| |
| @Test |
| public void testDefaultString_defaultValue() |
| { |
| assertThat( StringUtils.defaultString( null, "defaultValue" ) |
| , is( "defaultValue" ) ); |
| |
| assertThat( StringUtils.defaultString( "dings", "defaultValue" ) |
| , is( "dings" ) ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testDeleteWhitespace_NPE() |
| { |
| StringUtils.deleteWhitespace( null ); |
| } |
| |
| @Test |
| public void testDeleteWhitespace() |
| { |
| assertThat( StringUtils.deleteWhitespace( " \t \n" ) |
| , is( "" ) ); |
| |
| assertThat( StringUtils.deleteWhitespace( " \t \b \n" ) |
| , is( "\b" ) ); |
| |
| assertThat( StringUtils.deleteWhitespace( "dings" ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.deleteWhitespace( "\n dings \t " ) |
| , is( "dings" ) ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testDifference_NPE() |
| { |
| StringUtils.difference( null, null ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testDifference_NPE2() |
| { |
| StringUtils.difference( null, "another" ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testDifference_NPE3() |
| { |
| StringUtils.difference( "this", null ); |
| } |
| |
| @Test |
| public void testDifference() |
| { |
| assertThat( StringUtils.difference( "this", "another" ) |
| , is( "another" ) ); |
| |
| assertThat( StringUtils.difference( "I am human", "I am a robot" ) |
| , is( "a robot" ) ); |
| |
| assertThat( StringUtils.difference( "I am human", "I AM a robot" ) |
| , is( "AM a robot" ) ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testDifferenceAt_NPE() |
| { |
| StringUtils.differenceAt( null, null ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testDifferenceAt_NPE2() |
| { |
| StringUtils.differenceAt( "test", null ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testDifferenceAt_NPE3() |
| { |
| StringUtils.differenceAt( null, "test" ); |
| } |
| |
| @Test |
| public void testDifferenceAt() |
| { |
| assertThat( StringUtils.differenceAt( "this", "another" ) |
| , is( 0 ) ); |
| |
| assertThat( StringUtils.differenceAt( "I am human", "I am a robot" ) |
| , is( 5 ) ); |
| |
| assertThat( StringUtils.differenceAt( "I am human", "I AM a robot" ) |
| , is( 2 ) ); |
| } |
| |
| @Test |
| public void testEndsWithIgnoreCase() |
| { |
| assertThat( StringUtils.endsWithIgnoreCase( null, null ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.endsWithIgnoreCase( null, "string" ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.endsWithIgnoreCase( "string", null ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.endsWithIgnoreCase( "string", "ing" ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.endsWithIgnoreCase( "string", "a string" ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.endsWithIgnoreCase( "string", "str" ) |
| , is( false ) ); |
| } |
| |
| @Test |
| public void testEquals() |
| { |
| assertThat( StringUtils.equals( null, null ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.equals( "x", null ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.equals( null, "x" ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.equals( "X", "x" ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.equals( "dings", "dings" ) |
| , is( true ) ); |
| } |
| |
| @Test |
| public void testEqualsIgnoreCase() |
| { |
| assertThat( StringUtils.equalsIgnoreCase( null, null ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.equalsIgnoreCase( "x", null ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.equalsIgnoreCase( null, "x" ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.equalsIgnoreCase( "X", "x" ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.equalsIgnoreCase( "dings", "dings" ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.equalsIgnoreCase( "dings", "diNGs" ) |
| , is( true ) ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testEscape_NPE() |
| { |
| StringUtils.escape( null ); |
| } |
| |
| @Test |
| public void testEscape() |
| { |
| assertThat( StringUtils.escape( "dings" ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.escape( "dings\tbums" ) |
| , is( "dings\\tbums" ) ); |
| |
| assertThat( StringUtils.escape( "dings\nbums" ) |
| , is( "dings\\nbums" ) ); |
| } |
| |
| |
| @Test |
| public void testEscape2() |
| { |
| assertThat( StringUtils.escape( null, null, '#' ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.escape( "dings", new char[]{ '\t', '\b' }, '+' ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.escape( "dings\tbums", new char[]{ '\t', '\b' }, '+' ) |
| , is( "dings+\tbums" ) ); |
| |
| assertThat( StringUtils.escape( "dings\nbums", new char[]{ '\t', '\b' }, '+' ) |
| , is( "dings\nbums" ) ); |
| assertThat( StringUtils.escape( "dings\bbums", new char[]{ '\t', '\b' }, '+' ) |
| , is( "dings+\bbums" ) ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testGetChomp_NPE1() |
| { |
| StringUtils.getChomp( null, null ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testGetChomp_NPE2() |
| { |
| StringUtils.getChomp( "dings", null ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testGetChomp_NPE3() |
| { |
| StringUtils.getChomp( null, "dings" ); |
| } |
| |
| @Test |
| public void testGetChomp() |
| { |
| assertThat( StringUtils.getChomp( "dings-bums", "-" ) |
| , is( "-bums" ) ); |
| |
| assertThat( StringUtils.getChomp( "dings-", "-" ) |
| , is( "-" ) ); |
| |
| assertThat( StringUtils.getChomp( "dingsbums", "-" ) |
| , is( "" ) ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testGetNestedString_NPE() |
| { |
| assertThat( StringUtils.getNestedString( " +dings+ ", null ) |
| , nullValue() ); |
| } |
| |
| @Test |
| public void testGetNestedString() |
| { |
| assertThat( StringUtils.getNestedString( null, null ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.getNestedString( " +dings+ ", "+" ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.getNestedString( " +dings+ ", "not" ) |
| , nullValue() ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testGetNestedString2_NPE1() |
| { |
| assertThat( StringUtils.getNestedString( " +dings+ ", null, null ) |
| , nullValue() ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testGetNestedString2_NPE2() |
| { |
| assertThat( StringUtils.getNestedString( " +dings+ ", null, "neither" ) |
| , nullValue() ); |
| } |
| |
| @Test |
| public void testGetNestedString2() |
| { |
| assertThat( StringUtils.getNestedString( null, null, null ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.getNestedString( " +dings+ ", "not", null ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.getNestedString( " +dings- ", "+", "-" ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.getNestedString( " +dings+ ", "not", "neither" ) |
| , nullValue() ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testGetPrechomp_NPE1() |
| { |
| StringUtils.getPrechomp( null, null ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testGetPrechomp_NPE2() |
| { |
| StringUtils.getPrechomp( null, "bums" ); |
| } |
| |
| @Test |
| public void testGetPrechomp() |
| { |
| assertThat( StringUtils.getPrechomp( "dings bums dongs", "bums" ) |
| , is( "dings bums" ) ); |
| |
| assertThat( StringUtils.getPrechomp( "dings bums dongs", "non" ) |
| , is( "" ) ); |
| } |
| |
| @Test |
| public void testIndexOfAny() |
| { |
| assertThat( StringUtils.indexOfAny( null, null ) |
| , is( -1 ) ); |
| |
| assertThat( StringUtils.indexOfAny( "dings", null ) |
| , is( -1 ) ); |
| |
| assertThat( StringUtils.indexOfAny( null, new String[]{} ) |
| , is( -1 ) ); |
| |
| assertThat( StringUtils.indexOfAny( "dings bums dongs", new String[]{ "knuff", "bums" } ) |
| , is( 6 ) ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testInterpolate_NPE() |
| { |
| StringUtils.interpolate( null, null ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testInterpolate_NPE2() |
| { |
| StringUtils.interpolate( "This ${text} will get replaced", null ); |
| } |
| |
| @Test |
| public void testInterpolate() |
| { |
| Map<String, String> variables = new HashMap<String, String>(); |
| assertThat( StringUtils.interpolate( "This ${text} will get replaced", variables ) |
| , is( "This ${text} will get replaced" ) ); |
| |
| variables.put( "text", "with a special content" ); |
| |
| assertThat( StringUtils.interpolate( "This ${text} will get replaced", variables ) |
| , is( "This with a special content will get replaced" ) ); |
| } |
| |
| @Test |
| public void testIsAlpha() |
| { |
| assertThat( StringUtils.isAlpha( null ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.isAlpha( "2" ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.isAlpha( "asvsdfSDF" ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.isAlpha( "asvsdfSDF \t " ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.isAlpha( "435afsafd3!" ) |
| , is( false ) ); |
| } |
| |
| @Test |
| public void testIsAlphaSpace() |
| { |
| assertThat( StringUtils.isAlphaSpace( null ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.isAlphaSpace( "2" ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.isAlphaSpace( "asvsdfSDF" ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.isAlphaSpace( "asvsdfSDF " ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.isAlphaSpace( "asvsdfSDF \t " ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.isAlphaSpace( "435afsafd3!" ) |
| , is( false ) ); |
| } |
| |
| @Test |
| public void testIsAlphanumeric() |
| { |
| assertThat( StringUtils.isAlphanumeric( null ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.isAlphanumeric( "2" ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.isAlphanumeric( "asvsdfSDF" ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.isAlphanumeric( "asvsdfSDF " ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.isAlphanumeric( "asvsdfSDF \t " ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.isAlphanumeric( "435afsafd3!" ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.isAlphanumeric( "435afsafd3" ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.isAlphanumeric( "435 " ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.isAlphanumeric( "435" ) |
| , is( true ) ); |
| } |
| |
| @Test |
| public void testIsAlphanumericSpace() |
| { |
| assertThat( StringUtils.isAlphanumericSpace( null ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.isAlphanumericSpace( "2" ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.isAlphanumericSpace( "asvsdfSDF" ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.isAlphanumericSpace( "asvsdfSDF " ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.isAlphanumericSpace( "asvsdfSDF \t " ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.isAlphanumericSpace( "435afsafd3!" ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.isAlphanumericSpace( "435afsafd3" ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.isAlphanumericSpace( "435 " ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.isAlphanumericSpace( "435" ) |
| , is( true ) ); |
| } |
| |
| @Test |
| public void testIsBlank() |
| { |
| assertThat( StringUtils.isBlank( null ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.isBlank( "xx" ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.isBlank( "xx " ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.isBlank( " " ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.isBlank( " \t " ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.isBlank( " \n " ) |
| , is( true ) ); |
| } |
| |
| |
| @Test |
| public void testEmpty() |
| { |
| assertThat( StringUtils.isEmpty( null ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.isEmpty( "xx" ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.isEmpty( "xx " ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.isEmpty( " " ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.isEmpty( " \t " ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.isEmpty( " \n " ) |
| , is( true ) ); |
| } |
| |
| @Test |
| public void testNotBlank() |
| { |
| assertThat( StringUtils.isNotBlank( null ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.isNotBlank( "xx" ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.isNotBlank( "xx " ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.isNotBlank( " " ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.isNotBlank( " \t " ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.isNotBlank( " \n " ) |
| , is( false ) ); |
| } |
| |
| @Test |
| public void testNotEmpty() |
| { |
| assertThat( StringUtils.isNotEmpty( null ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.isNotEmpty( "xx" ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.isNotEmpty( "xx " ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.isNotEmpty( " " ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.isNotEmpty( "" ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.isNotEmpty( " \t " ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.isNotEmpty( " \n " ) |
| , is( true ) ); |
| } |
| |
| @Test |
| public void testIsNumeric() |
| { |
| assertThat( StringUtils.isNumeric( null ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.isNumeric( "2" ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.isNumeric( "asvsdfSDF" ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.isNumeric( "asvsdfSDF " ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.isNumeric( "asvsdfSDF \t " ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.isNumeric( "435afsafd3!" ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.isNumeric( "435afsafd3" ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.isNumeric( "435 " ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.isNumeric( "435" ) |
| , is( true ) ); |
| } |
| |
| @Test |
| public void testIsWhitespace() |
| { |
| assertThat( StringUtils.isWhitespace( null ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.isWhitespace( "xx" ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.isWhitespace( "xx " ) |
| , is( false ) ); |
| |
| assertThat( StringUtils.isWhitespace( " " ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.isWhitespace( "" ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.isWhitespace( " \t " ) |
| , is( true ) ); |
| |
| assertThat( StringUtils.isWhitespace( " \n " ) |
| , is( true ) ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testJoin_Array_NPE() |
| { |
| StringUtils.join( ( Object[] ) null, null ); |
| } |
| |
| @Test |
| public void testJoin_Array() |
| { |
| assertThat( StringUtils.join( new Object[0], null ) |
| , is( "" ) ); |
| |
| assertThat( StringUtils.join( new Object[]{ "a", "b", "c" }, null ) |
| , is( "abc" ) ); |
| |
| assertThat( StringUtils.join( new Object[]{ "a", "b", "c" }, "__" ) |
| , is( "a__b__c" ) ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testJoin_Iterator_NPE() |
| { |
| StringUtils.join( (Iterator<?>) null, null ); |
| } |
| |
| @Test |
| public void testJoin_Iterator() |
| { |
| ArrayList<String> list = new ArrayList<String>(); |
| |
| assertThat( StringUtils.join( list.iterator(), null ) |
| , is( "" ) ); |
| |
| list.add( "a" ); |
| list.add( "b" ); |
| list.add( "c" ); |
| |
| assertThat( StringUtils.join( list.iterator(), null ) |
| , is( "abc" ) ); |
| |
| assertThat( StringUtils.join( list.iterator(), "__" ) |
| , is( "a__b__c" ) ); |
| } |
| |
| @Test |
| public void testLastIndexOfAny() |
| { |
| assertThat( StringUtils.lastIndexOfAny( null, null ) |
| , is( -1 ) ); |
| |
| assertThat( StringUtils.lastIndexOfAny( "dings", null ) |
| , is( -1 ) ); |
| |
| assertThat( StringUtils.lastIndexOfAny( "dings bums boms", new String[] { "ms", " b" } ) |
| , is( 13 ) ); |
| |
| assertThat( StringUtils.lastIndexOfAny( "dings bums boms", new String[] { "nix", "da" } ) |
| , is( -1 ) ); |
| } |
| |
| @Test( expected = IllegalArgumentException.class ) |
| public void testLeft_IAE() |
| { |
| StringUtils.left( null, -1 ); |
| } |
| |
| @Test |
| public void testLeft() |
| { |
| assertThat( StringUtils.left( null, 4 ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.left( "dingsbums", 4 ) |
| , is( "ding" ) ); |
| |
| assertThat( StringUtils.left( "dingsbums", 40 ) |
| , is( "dingsbums" ) ); |
| |
| assertThat( StringUtils.left( "dingsbums", 0 ) |
| , is( "" ) ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testLeftPad1_NPE() |
| { |
| StringUtils.leftPad( null, 0 ); |
| } |
| |
| @Test |
| public void testLeftPad1() |
| { |
| assertThat( StringUtils.leftPad( "dings", 0 ) |
| , is( "dings") ); |
| |
| assertThat( StringUtils.leftPad( "dings", 2 ) |
| , is( "dings") ); |
| |
| assertThat( StringUtils.leftPad( "dings", 10 ) |
| , is( " dings") ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testLeftPad2_NPE1() |
| { |
| StringUtils.leftPad( null, 0, null ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testLeftPad2_NPE2() |
| { |
| StringUtils.leftPad( "dings", 0, null ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testLeftPad2_NPE3() |
| { |
| StringUtils.leftPad( null, 0, "*" ); |
| } |
| |
| @Test |
| public void testLeftPad2() |
| { |
| assertThat( StringUtils.leftPad( "dings", 0, "*" ) |
| , is( "dings") ); |
| |
| assertThat( StringUtils.leftPad( "dings", 2, "*" ) |
| , is( "dings") ); |
| |
| assertThat( StringUtils.leftPad( "dings", 10, "*" ) |
| , is( "*****dings") ); |
| } |
| |
| @Test |
| public void testLowerCase() |
| { |
| assertThat( StringUtils.lowerCase( null ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.lowerCase( "dinGSbuMS" ) |
| , is( "dingsbums" ) ); |
| |
| assertThat( StringUtils.lowerCase( "" ) |
| , is( "" ) ); |
| |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testLowerCaseFirstLetter_NPE() |
| { |
| StringUtils.lowercaseFirstLetter( null ); |
| } |
| |
| @Test |
| public void testLowerCaseFirstLetter() |
| { |
| assertThat( StringUtils.lowercaseFirstLetter( "Dings Bums" ) |
| , is( "dings Bums" ) ); |
| } |
| |
| @Test( expected = IllegalArgumentException.class ) |
| public void testMid_NegativeLen() |
| { |
| StringUtils.mid( null, 0, -2 ); |
| } |
| |
| @Test( expected = IndexOutOfBoundsException.class ) |
| public void testMid_WrongPos() |
| { |
| StringUtils.mid( null, -2, 3 ); |
| } |
| |
| @Test |
| public void testMid() |
| { |
| assertThat( StringUtils.mid( null, 0, 0 ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.mid( "dings bums", 0, 0 ) |
| , is( "" ) ); |
| |
| assertThat( StringUtils.mid( "dings bums", 3, 4 ) |
| , is( "gs b" ) ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testOverlayString_NPE1() |
| { |
| StringUtils.overlayString( null, null, 0, 0 ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testOverlayString_NPE2() |
| { |
| StringUtils.overlayString( "dings", null, 0, 0 ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testOverlayString_NPE3() |
| { |
| StringUtils.overlayString( null, "bums", 0, 0 ); |
| } |
| |
| @Test |
| public void testOverlayString() |
| { |
| assertThat( StringUtils.overlayString( "dings", "bums", 0, 0 ) |
| , is( "bumsdings" ) ); |
| |
| assertThat( StringUtils.overlayString( "dings", "bums", 2, 4 ) |
| , is( "dibumss" ) ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testPrechomp_NPE1() |
| { |
| StringUtils.prechomp( null, null ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testPrechomp_NPE2() |
| { |
| StringUtils.prechomp( "dings", null ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testPrechomp_NPE3() |
| { |
| StringUtils.prechomp( null, "bums" ); |
| } |
| |
| @Test |
| public void testPrechomp() |
| { |
| assertThat( StringUtils.prechomp( "dings bums", " " ) |
| , is( "bums" ) ); |
| |
| assertThat( StringUtils.prechomp( "dings bums", "nix" ) |
| , is( "dings bums" ) ); |
| } |
| |
| @Test |
| public void testQuoteAndEscape1() |
| { |
| assertThat( StringUtils.quoteAndEscape( null, '+' ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.quoteAndEscape( "", '+' ) |
| , is( "" ) ); |
| |
| assertThat( StringUtils.quoteAndEscape( "abc", '"' ) |
| , is( "abc" ) ); |
| |
| assertThat( StringUtils.quoteAndEscape( "a\"bc", '"' ) |
| , is( "\"a\\\"bc\"" ) ); |
| |
| assertThat( StringUtils.quoteAndEscape( "a\'bc", '\'' ) |
| , is( "\'a\\'bc\'" ) ); |
| |
| assertThat( StringUtils.quoteAndEscape( "a\"bc", '\'' ) |
| , is( "a\"bc" ) ); |
| } |
| |
| @Test |
| public void testQuoteAndEscape2() |
| { |
| assertThat( StringUtils.quoteAndEscape( null, '+', new char[]{ '"' } ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.quoteAndEscape( "", '+', new char[]{ '"' } ) |
| , is( "" ) ); |
| |
| assertThat( StringUtils.quoteAndEscape( "abc", '"', new char[]{ '"' } ) |
| , is( "abc" ) ); |
| |
| assertThat( StringUtils.quoteAndEscape( "a\"bc", '"', new char[]{ '"' } ) |
| , is( "\"a\\\"bc\"" ) ); |
| |
| assertThat( StringUtils.quoteAndEscape( "a\'bc", '\'', new char[]{ '"' } ) |
| , is( "\'a\\'bc\'" ) ); |
| |
| assertThat( StringUtils.quoteAndEscape( "a\"bc", '\'', new char[]{ '\'' } ) |
| , is( "a\"bc" ) ); |
| |
| assertThat( StringUtils.quoteAndEscape( "a\"bc", '\'', new char[]{ '\'', '"' } ) |
| , is( "\'a\"bc\'" ) ); |
| } |
| |
| @Test |
| public void testQuoteAndEscape3() |
| { |
| assertThat( StringUtils.quoteAndEscape( null, '+', new char[]{ '"' }, '\\', false ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.quoteAndEscape( "", '+', new char[]{ '"' }, '\\', false ) |
| , is( "" ) ); |
| |
| assertThat( StringUtils.quoteAndEscape( "abc", '"', new char[]{ '"' }, '\\', false ) |
| , is( "abc" ) ); |
| |
| assertThat( StringUtils.quoteAndEscape( "a\"bc", '"', new char[]{ '"' }, '\\', false ) |
| , is( "\"a\\\"bc\"" ) ); |
| |
| assertThat( StringUtils.quoteAndEscape( "a\'bc", '\'', new char[]{ '"' }, '\\', false ) |
| , is( "a\'bc" ) ); |
| |
| assertThat( StringUtils.quoteAndEscape( "a\"bc", '\'', new char[]{ '\'' }, '\\', false ) |
| , is( "a\"bc" ) ); |
| |
| assertThat( StringUtils.quoteAndEscape( "a\"bc", '\'', new char[]{ '\'', '"' }, '\\', false ) |
| , is( "\'a\\\"bc\'" ) ); |
| |
| // with force flag |
| assertThat( StringUtils.quoteAndEscape( null, '+', new char[]{ '"' }, '\\', true ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.quoteAndEscape( "", '+', new char[]{ '"' }, '\\', true ) |
| , is( "++" ) ); |
| |
| assertThat( StringUtils.quoteAndEscape( "abc", '"', new char[]{ '"' }, '\\', true ) |
| , is( "\"abc\"" ) ); |
| |
| assertThat( StringUtils.quoteAndEscape( "a\"bc", '"', new char[]{ '"' }, '\\', true ) |
| , is( "\"a\\\"bc\"" ) ); |
| |
| assertThat( StringUtils.quoteAndEscape( "a\'bc", '\'', new char[]{ '"' }, '\\', true ) |
| , is( "\'a\'bc\'" ) ); |
| |
| assertThat( StringUtils.quoteAndEscape( "a\"bc", '\'', new char[]{ '\'' }, '\\', true ) |
| , is( "\'a\"bc\'" ) ); |
| |
| assertThat( StringUtils.quoteAndEscape( "a\"bc", '\'', new char[]{ '\'', '"' }, '\\', true ) |
| , is( "\'a\\\"bc\'" ) ); |
| } |
| |
| @Test |
| public void testQuoteAndEscape4() |
| { |
| assertThat( StringUtils.quoteAndEscape( null, '+', new char[]{ '"' }, new char[]{ '"' }, '\\', false ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.quoteAndEscape( "", '+', new char[]{ '"' }, new char[]{ '"' }, '\\', false ) |
| , is( "" ) ); |
| |
| assertThat( StringUtils.quoteAndEscape( "abc", '"', new char[]{ '"' }, new char[]{ '"' }, '\\', false ) |
| , is( "abc" ) ); |
| |
| assertThat( StringUtils.quoteAndEscape( "a\"bc", '"', new char[]{ '"' }, new char[]{ '"' }, '\\', false ) |
| , is( "\"a\\\"bc\"" ) ); |
| |
| assertThat( StringUtils.quoteAndEscape( "a\'bc", '\'', new char[]{ '"' }, new char[]{ '"' }, '\\', false ) |
| , is( "a\'bc" ) ); |
| |
| assertThat( StringUtils.quoteAndEscape( "a\"bc", '\'', new char[]{ '\'' }, new char[]{ '"' }, '\\', false ) |
| , is( "\'a\"bc\'" ) ); |
| |
| assertThat( StringUtils.quoteAndEscape( "\'a\"bc\'", '\'', new char[]{ '\'', '"' }, new char[]{ '"' }, '\\', false ) |
| , is( "\'a\"bc\'" ) ); |
| |
| // with force flag |
| assertThat( StringUtils.quoteAndEscape( null, '+', new char[]{ '"' }, new char[]{ '"' }, '\\', true ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.quoteAndEscape( "", '+', new char[]{ '"' }, new char[]{ '"' }, '\\', true ) |
| , is( "++" ) ); |
| |
| assertThat( StringUtils.quoteAndEscape( "abc", '"', new char[]{ '"' }, new char[]{ '"' }, '\\', true ) |
| , is( "\"abc\"" ) ); |
| |
| assertThat( StringUtils.quoteAndEscape( "a\"bc", '"', new char[]{ '"' }, new char[]{ '"' }, '\\', true ) |
| , is( "\"a\\\"bc\"" ) ); |
| |
| assertThat( StringUtils.quoteAndEscape( "a\'bc", '\'', new char[]{ '"' }, new char[]{ '"' }, '\\', true ) |
| , is( "\'a\'bc\'" ) ); |
| |
| assertThat( StringUtils.quoteAndEscape( "a\"bc", '\'', new char[]{ '\'' }, new char[]{ '"' }, '\\', true ) |
| , is( "\'a\"bc\'" ) ); |
| |
| assertThat( StringUtils.quoteAndEscape( "a\"bc", '\'', new char[]{ '\'', '"' }, new char[]{ '"' }, '\\', true ) |
| , is( "\'a\\\"bc\'" ) ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testRemoveAndHump_NPE1() |
| { |
| StringUtils.removeAndHump( null, null ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testRemoveAndHump_NPE2() |
| { |
| StringUtils.removeAndHump( "dings", null ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testRemoveAndHump_NPE3() |
| { |
| StringUtils.removeAndHump( null, "bums" ); |
| } |
| |
| @Test |
| public void testRemoveAndHump() |
| { |
| assertThat( StringUtils.removeAndHump( "dings", "bums" ) |
| , is( "Ding" ) ); |
| |
| assertThat( StringUtils.removeAndHump( "this-is-it", "-" ) |
| , is( "ThisIsIt" ) ); |
| |
| assertThat( StringUtils.removeAndHump( "THIS-IS-IT", "-" ) |
| , is( "THISISIT" ) ); |
| |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testRemoveDuplicateWhitespace_NPE() |
| { |
| StringUtils.removeDuplicateWhitespace( null ); |
| } |
| |
| @Test |
| public void testRemoveDuplicateWhitespace() |
| { |
| assertThat( StringUtils.removeDuplicateWhitespace( "dings" ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.removeDuplicateWhitespace( "dings bums" ) |
| , is( "dings bums" ) ); |
| |
| assertThat( StringUtils.removeDuplicateWhitespace( "dings bums" ) |
| , is( "dings bums" ) ); |
| |
| assertThat( StringUtils.removeDuplicateWhitespace( "dings \t bums" ) |
| , is( "dings bums" ) ); |
| |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testRepeat_NPE() |
| { |
| StringUtils.repeat( null, 0 ); |
| } |
| |
| @Test( expected = NegativeArraySizeException.class ) |
| public void testRepeat_NegativeAmount() |
| { |
| StringUtils.repeat( "dings", -1 ); |
| } |
| |
| |
| @Test |
| public void testRepeat() |
| { |
| assertThat( StringUtils.repeat( "dings", 0 ) |
| , is( "" ) ); |
| |
| assertThat( StringUtils.repeat( "dings", 1 ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.repeat( "dings", 3 ) |
| , is( "dingsdingsdings" ) ); |
| } |
| |
| |
| @Test |
| public void testReplace_char() |
| { |
| assertThat( StringUtils.replace( null, 'i', 'o' ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.replace( "dings", 'i', 'o' ) |
| , is( "dongs" ) ); |
| |
| assertThat( StringUtils.replace( "dingsbims", 'i', 'o' ) |
| , is( "dongsboms" ) ); |
| |
| assertThat( StringUtils.replace( "dings", 'x', 'o' ) |
| , is( "dings" ) ); |
| } |
| |
| @Test |
| public void testReplace2_char_max() |
| { |
| assertThat( StringUtils.replace( null, 'i', 'o', 0 ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.replace( "dingsibumsi", 'i', 'o', 3 ) |
| , is( "dongsobumso" ) ); |
| |
| assertThat( StringUtils.replace( "dingsibumsi", 'i', 'o', 2 ) |
| , is( "dongsobumsi" ) ); |
| |
| assertThat( StringUtils.replace( "dingsibumsi", 'i', 'o', 0 ) |
| , is( "dongsobumso" ) ); |
| |
| assertThat( StringUtils.replace( "dingsibumsi", 'i', 'o', -2 ) |
| , is( "dongsobumso" ) ); |
| |
| assertThat( StringUtils.replace( "dings", 'x', 'o', 2 ) |
| , is( "dings" ) ); |
| } |
| |
| @Test |
| public void testReplace_string() |
| { |
| assertThat( StringUtils.replace( null, "in", "ox" ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.replace( "dings", "in", "ox" ) |
| , is( "doxgs" ) ); |
| |
| assertThat( StringUtils.replace( "dingsbins", "in", "ox" ) |
| , is( "doxgsboxs" ) ); |
| |
| assertThat( StringUtils.replace( "dings", "nin", "ox" ) |
| , is( "dings" ) ); |
| } |
| |
| |
| @Test |
| public void testReplace2_string_max() |
| { |
| assertThat( StringUtils.replace( null, "in", "ox", 0 ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.replace( "dingsibumsi", "si", "xo", 3 ) |
| , is( "dingxobumxo" ) ); |
| |
| assertThat( StringUtils.replace( "dingsibumsi", "si", "xo", 2 ) |
| , is( "dingxobumxo" ) ); |
| |
| assertThat( StringUtils.replace( "dingsibumsi", "si", "xo", 1 ) |
| , is( "dingxobumsi" ) ); |
| |
| assertThat( StringUtils.replace( "dingsibumsi", "si", "xo", 0 ) |
| , is( "dingxobumxo" ) ); |
| |
| assertThat( StringUtils.replace( "dingsibumsi", "si", "xo", -2 ) |
| , is( "dingxobumxo" ) ); |
| |
| assertThat( StringUtils.replace( "dings", "si", "xo", 2 ) |
| , is( "dings" ) ); |
| } |
| |
| @Test |
| public void testReplaceOnce_char() |
| { |
| assertThat( StringUtils.replaceOnce( null, 'i', 'o' ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.replaceOnce( "dingsibumsi", 'i', 'o' ) |
| , is( "dongsibumsi" ) ); |
| |
| assertThat( StringUtils.replaceOnce( "dings", 'x', 'o' ) |
| , is( "dings" ) ); |
| } |
| |
| @Test |
| public void testReplaceOnce_string() |
| { |
| assertThat( StringUtils.replaceOnce( null, "in", "ox" ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.replaceOnce( "dingsibumsi", "si", "xo" ) |
| , is( "dingxobumsi" ) ); |
| |
| assertThat( StringUtils.replaceOnce( "dings", "si", "xo" ) |
| , is( "dings" ) ); |
| } |
| |
| |
| @Test |
| public void testReverse() |
| { |
| assertThat( StringUtils.reverse( null ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.reverse( "" ) |
| , is( "" ) ); |
| |
| assertThat( StringUtils.reverse( "dings" ) |
| , is( "sgnid" ) ); |
| |
| assertThat( StringUtils.reverse( " dings " ) |
| , is( " sgnid " ) ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testReverseDelimitedString_NPE1() |
| { |
| StringUtils.reverseDelimitedString( null, null ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testReverseDelimitedString_NPE2() |
| { |
| StringUtils.reverseDelimitedString( null, " " ); |
| } |
| |
| @Test |
| public void testReverseDelimitedString() |
| { |
| assertThat( StringUtils.reverseDelimitedString( "dings", null ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.reverseDelimitedString( "", " " ) |
| , is( "" ) ); |
| |
| assertThat( StringUtils.reverseDelimitedString( "dings", " " ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.reverseDelimitedString( " dings ", " " ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.reverseDelimitedString( "dings bums", " " ) |
| , is( "bums dings" ) ); |
| } |
| |
| @Test( expected = IllegalArgumentException.class ) |
| public void testRight_IAE1() |
| { |
| StringUtils.right( null, -1 ); |
| } |
| |
| @Test( expected = IllegalArgumentException.class ) |
| public void testRight_IAE2() |
| { |
| StringUtils.right( "dings", -1 ); |
| } |
| |
| @Test |
| public void testRight() |
| { |
| assertThat( StringUtils.right( null, 0 ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.right( "dings", 0 ) |
| , is( "" ) ); |
| |
| assertThat( StringUtils.right( "dings", 3 ) |
| , is( "ngs" ) ); |
| |
| assertThat( StringUtils.right( "dings ", 3 ) |
| , is( "gs " ) ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testRightPad1_NPE() |
| { |
| StringUtils.rightPad( null, 0 ); |
| } |
| |
| @Test |
| public void testRightPad1() |
| { |
| assertThat( StringUtils.rightPad( "dings", 0 ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.rightPad( "dings", 3 ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.rightPad( "dings", 10 ) |
| , is( "dings " ) ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testRightPad2_NPE1() |
| { |
| StringUtils.rightPad( null, 0, null ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testRightPad2_NPE2() |
| { |
| StringUtils.rightPad( "dings", 0, null ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testRightPad2_NPE23() |
| { |
| StringUtils.rightPad( null, 0, "+" ); |
| } |
| |
| @Test |
| public void testRightPad2() |
| { |
| assertThat( StringUtils.rightPad( "dings", 0, "+" ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.rightPad( "dings", 3, "+" ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.rightPad( "dings", 10, "+" ) |
| , is( "dings+++++" ) ); |
| } |
| |
| |
| @Test( expected = NullPointerException.class ) |
| public void testSplit1_NPE() |
| { |
| StringUtils.split( null ); |
| } |
| |
| @Test |
| public void testSplit1() |
| { |
| assertThat( StringUtils.split( "dings" ) |
| , is( new String[]{ "dings" } ) ); |
| |
| assertThat( StringUtils.split( "dings bums" ) |
| , is( new String[]{ "dings", "bums" } ) ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testSplit2_NPE1() |
| { |
| StringUtils.split( null, null ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testSplit2_NPE2() |
| { |
| StringUtils.split( null, " " ); |
| } |
| |
| @Test |
| public void testSplit2() |
| { |
| assertThat( StringUtils.split( "dings", null ) |
| , is( new String[]{ "dings" } ) ); |
| |
| assertThat( StringUtils.split( "dings bums", null ) |
| , is( new String[]{ "dings", "bums" } ) ); |
| |
| assertThat( StringUtils.split( "dings", "+" ) |
| , is( new String[]{ "dings" } ) ); |
| |
| assertThat( StringUtils.split( "dings+bums", "+" ) |
| , is( new String[]{ "dings", "bums" } ) ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testSplit3_NPE1() |
| { |
| StringUtils.split( null, null, 1 ); |
| } |
| |
| @Test( expected = NullPointerException.class ) |
| public void testSplit3_NPE2() |
| { |
| StringUtils.split( null, " ", 1 ); |
| } |
| |
| @Test |
| public void testSplit3() |
| { |
| assertThat( StringUtils.split( "dings", null, 3 ) |
| , is( new String[]{ "dings" } ) ); |
| |
| assertThat( StringUtils.split( "dings bums", null, 3 ) |
| , is( new String[]{ "dings", "bums" } ) ); |
| |
| assertThat( StringUtils.split( "dings", "+", 3 ) |
| , is( new String[]{ "dings" } ) ); |
| |
| assertThat( StringUtils.split( "dings+bums", "+", 3 ) |
| , is( new String[]{ "dings", "bums" } ) ); |
| |
| assertThat( StringUtils.split( "dings+bums", "+", 1 ) |
| , is( new String[]{ "dings+bums" } ) ); |
| |
| assertThat( StringUtils.split( "dings+bums", "+", 0 ) |
| , is( new String[]{ "dings", "bums" } ) ); |
| |
| assertThat( StringUtils.split( "dings+bums", "+", -5 ) |
| , is( new String[]{ "dings", "bums" } ) ); |
| |
| } |
| |
| |
| @Test |
| public void testStrip1() |
| { |
| assertThat( StringUtils.strip( null ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.strip( "dings" ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.strip( " dings \t " ) |
| , is( "dings" ) ); |
| } |
| |
| @Test |
| public void testStrip2() |
| { |
| assertThat( StringUtils.strip( null, " " ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.strip( null, null ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.strip( "dings", " " ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.strip( " dings \t ", " " ) |
| , is( "dings \t" ) ); |
| } |
| |
| @Test |
| public void testStripAll1() |
| { |
| assertThat( StringUtils.stripAll( null ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.stripAll( new String[]{} ) |
| , is( new String[]{} ) ); |
| |
| assertThat( StringUtils.stripAll( new String[]{ "dings" } ) |
| , is( new String[]{ "dings" } ) ); |
| |
| assertThat( StringUtils.stripAll( new String[]{ " dings ", " bums \t " } ) |
| , is( new String[]{ "dings", "bums" } ) ); |
| } |
| |
| @Test |
| public void testStripAll2() |
| { |
| assertThat( StringUtils.stripAll( null, " " ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.stripAll( new String[]{}, " " ) |
| , is( new String[]{} ) ); |
| |
| assertThat( StringUtils.stripAll( new String[]{ "dings" }, " " ) |
| , is( new String[]{ "dings" } ) ); |
| |
| assertThat( StringUtils.stripAll( new String[]{ " dings ", " bums \t " }, " " ) |
| , is( new String[]{ "dings", "bums \t" } ) ); |
| } |
| |
| @Test |
| public void testStripEnd() |
| { |
| assertThat( StringUtils.stripEnd( null, null ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.stripEnd( "dings", null ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.stripEnd( " dings \t ", null ) |
| , is( " dings" ) ); |
| |
| assertThat( StringUtils.stripEnd( null, " " ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.stripEnd( "dings", " " ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.stripEnd( " dings \t ", " " ) |
| , is( " dings \t" ) ); |
| } |
| |
| @Test |
| public void testStripStart() |
| { |
| assertThat( StringUtils.stripStart( null, null ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.stripStart( "dings", null ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.stripStart( " dings \t ", null ) |
| , is( "dings \t " ) ); |
| |
| assertThat( StringUtils.stripStart( null, " " ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.stripStart( "dings", " " ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.stripStart( " \t dings \t ", " " ) |
| , is( "\t dings \t " ) ); |
| } |
| |
| @Test |
| public void testSubstring1() |
| { |
| assertThat( StringUtils.substring( null, 0 ) |
| , nullValue() ); |
| assertThat( StringUtils.substring( null, -3 ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.substring( "dings", 2 ) |
| , is( "ngs" ) ); |
| |
| assertThat( StringUtils.substring( "dings", -2 ) |
| , is( "gs" ) ); |
| |
| assertThat( StringUtils.substring( "dings", 20 ) |
| , is( "" ) ); |
| } |
| |
| @Test |
| public void testSubstring2() |
| { |
| assertThat( StringUtils.substring( null, 0, 2 ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.substring( null, -3, 0 ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.substring( "dings", 2, 4 ) |
| , is( "ng" ) ); |
| |
| assertThat( StringUtils.substring( "dings", -2, 4 ) |
| , is( "g" ) ); |
| |
| assertThat( StringUtils.substring( "dings", 20, 23 ) |
| , is( "" ) ); |
| |
| assertThat( StringUtils.substring( "dings", 4, 2 ) |
| , is( "" ) ); |
| } |
| |
| @Test |
| public void testSwapCase() |
| { |
| assertThat( StringUtils.swapCase( null ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.swapCase( "dings" ) |
| , is( "DINGS" ) ); |
| |
| assertThat( StringUtils.swapCase( "DinGs" ) |
| , is( "dINgS" ) ); |
| |
| } |
| |
| @Test |
| public void testTrim() |
| { |
| assertThat( StringUtils.trim( null ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.trim( " " ) |
| , is( "" ) ); |
| |
| assertThat( StringUtils.trim( " c " ) |
| , is( "c" ) ); |
| |
| assertThat( StringUtils.trim( " dings \n " ) |
| , is( "dings" ) ); |
| } |
| |
| @Test |
| public void testUncapitalise() |
| { |
| assertThat( StringUtils.uncapitalise( null ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.uncapitalise( " " ) |
| , is( " " ) ); |
| |
| assertThat( StringUtils.uncapitalise( "dings" ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.uncapitalise( "Dings" ) |
| , is( "dings" ) ); |
| |
| assertThat( StringUtils.uncapitalise( "DINGS" ) |
| , is( "dINGS" ) ); |
| } |
| |
| @Test |
| public void testUncapitaliseAllWords() |
| { |
| assertThat( StringUtils.uncapitaliseAllWords( null ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.uncapitaliseAllWords( " " ) |
| , is( " " ) ); |
| |
| assertThat( StringUtils.uncapitaliseAllWords( "dings bums" ) |
| , is( "dings bums" ) ); |
| |
| assertThat( StringUtils.uncapitaliseAllWords( "Dings Bums" ) |
| , is( "dings bums" ) ); |
| |
| assertThat( StringUtils.uncapitaliseAllWords( "DINGS Bums" ) |
| , is( "dINGS bums" ) ); |
| } |
| |
| @Test |
| public void testUnifyLineSeparators1() |
| { |
| String sls = System.getProperty( "line.separator" ); |
| |
| assertThat( StringUtils.unifyLineSeparators( null ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.unifyLineSeparators( " " ) |
| , is( " " ) ); |
| |
| assertThat( StringUtils.unifyLineSeparators( "dings\nbums\r\ndongs" ) |
| , is( "dings" + sls + "bums" + sls + "dongs") ); |
| } |
| |
| @Test |
| public void testUnifyLineSeparators2() |
| { |
| assertThat( StringUtils.unifyLineSeparators( null, "\n" ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.unifyLineSeparators( " ", "\n" ) |
| , is( " " ) ); |
| |
| assertThat( StringUtils.unifyLineSeparators( " ", null ) // takes the sytem line separator |
| , is( " " ) ); |
| |
| assertThat( StringUtils.unifyLineSeparators( "dings\nbums\r\ndongs", "\n" ) |
| , is( "dings\nbums\ndongs" ) ); |
| } |
| |
| @Test |
| public void testUppercase() |
| { |
| assertThat( StringUtils.upperCase( null ) |
| , nullValue() ); |
| |
| assertThat( StringUtils.upperCase( " " ) |
| , is( " " ) ); |
| |
| assertThat( StringUtils.upperCase( "" ) |
| , is( "" ) ); |
| |
| assertThat( StringUtils.upperCase( "dings" ) |
| , is( "DINGS" ) ); |
| |
| } |
| |
| } |