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

    }


}
