/*
    * Copyright (c) 1998, 2005 Gargoyle Software Inc. All rights reserved.
    *
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions are met:
    *
    * 1. Redistributions of source code must retain the above copyright notice,
    *    this list of conditions and the following disclaimer.
    * 2. Redistributions in binary form must reproduce the above copyright notice,
   *    this list of conditions and the following disclaimer in the documentation
   *    and/or other materials provided with the distribution.
   * 3. The end-user documentation included with the redistribution, if any, must
   *    include the following acknowledgment:
   *
   *       "This product includes software developed by Gargoyle Software Inc.
   *        (http://www.GargoyleSoftware.com/)."
   *
   *    Alternately, this acknowledgment may appear in the software itself, if
   *    and wherever such third-party acknowledgments normally appear.
   * 4. The name "Gargoyle Software" must not be used to endorse or promote
   *    products derived from this software without prior written permission.
   *    For written permission, please contact info@GargoyleSoftware.com.
   * 5. Products derived from this software may not be called "GSBase", nor may
   *    "GSBase" appear in their name, without prior written permission of
   *    Gargoyle Software Inc.
   *
   * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
   * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
   * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GARGOYLE
   * SOFTWARE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
   * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
   * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
   * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
   * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
   * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   */
  package com.gargoylesoftware.base.util;
  
  import java.util.Arrays;
  import java.util.List;
  import junit.framework.TestCase;
  
  /***
   *  Tests for StringUtil
   *
   * @version  $Revision: 1.6 $
   * @author  <a href="mailto:mbowler@GargoyleSoftware.com">Mike Bowler</a>
   */
  public class StringUtilTest extends TestCase {
  
      /***
       *  Create a new test.
       *
       * @param  name The name of the test.
       */
      public StringUtilTest( final String name ) {
          super( name );
      }
  
  
      /***
       *  Test joining ints together
       */
      public void testJoinInt() {
          assertEquals( "1,2,3", StringUtil.join( new int[]{1, 2, 3}, "," ) );
      }
  
  
      /*** */
      public void testJoinInt_EmptyArray() {
          assertEquals( "", StringUtil.join( new int[]{}, "," ) );
      }
  
      /*** */
      public void testJoinInt_OneElement() {
          assertEquals( "1", StringUtil.join( new int[]{1}, "," ) );
      }
  
      /*** */
      public void testJoinInt_NullArray() {
          try {
              assertEquals( "1", StringUtil.join( (int[])null, "," ) );
          }
          catch( final NullPointerException e ) {
              // expected path
          }
      }
  
      /*** */
      public void testJoinInt_NullSeparator() {
          try {
              assertEquals( "1", StringUtil.join( new int[]{2, 3}, null ) );
          }
          catch( final NullPointerException e ) {
              // Expected path
          }
      }
  
     /*** */
     public void testJoinCollection() {
         final List list = Arrays.asList( new String[]{"1", "2", "3"} );
         assertEquals( "1,2,3", StringUtil.join( list, "," ) );
     }
 
 
     /***
      *  Test splitAtFirst()
      */
     public void testSplitAtFirst() {
         final String data[][] = {
                 {"foo=bar", "=", "foo", "bar"},
                 {"foobar", "=", "foobar", ""},
                 {"foo=", "=", "foo", ""},
                 {"=bar", "=", "", "bar"}
                 };
 
         String result[];
 
         int i;
         for( i = 0; i < data.length; i++ ) {
             result = StringUtil.splitAtFirst( data[i][0], data[i][1] );
             assertEquals( "first", data[i][2], result[0] );
             assertEquals( "second", data[i][3], result[1] );
         }
     }
 
 
     /***
      *  Test split()
      */
     public void testSplit() {
         final Object data[][] = {
                 {"foo=bar", "=", new String[]{"foo", "bar"}},
                 {"foo!=bar", "!=", new String[]{"foo", "bar"}},
                 {"foo,bar,cat,dog", ",", new String[]{"foo", "bar", "cat", "dog"}},
                 {",foo,,cat,dog", ",", new String[]{"", "foo", "", "cat", "dog"}},
                 {"", "=", new String[0]},
                 {"foo", "=", new String[]{"foo"}},
                 {"==", "==", new String[]{"", ""}},
                 };
 
         String result[];
         String expectedResult[];
         String line;
         String separator;
 
         int i;
         int j;
         for( i = 0; i < data.length; i++ ) {
             line = ( String )data[i][0];
             separator = ( String )data[i][1];
             expectedResult = ( String[] )data[i][2];
 
             result = StringUtil.split( line, separator );
 
             assertEquals( "Number of strings for input[" + line + "]",
                     expectedResult.length,
                     result.length );
 
             for( j = 0; j < result.length; j++ ) {
                 assertEquals( "element[" + j + "] for input[" + line + "]",
                         expectedResult[j],
                         result[j] );
             }
         }
     }
 
 
     /***
      *  Test split() with a null line
      */
     public void testSplit_NullLine() {
         try {
             StringUtil.split( null, "," );
             fail( "Expected exception" );
         }
         catch( final DetailedNullPointerException e ) {
             assertEquals("line", e.getArgumentName());
         }
     }
 
 
     /***
      *  Test split() with a null separator
      */
     public void testSplit_NullSeparator() {
         try {
             StringUtil.split( "foo", null );
             fail( "Expected exception" );
         }
         catch( final DetailedNullPointerException e ) {
             assertEquals( "separator", e.getArgumentName() );
             // Expected path
         }
     }
 
 
     /***
      *  Test split() with an empty separator
      */
     public void testSplit_EmptySeparator() {
         try {
             StringUtil.split( "foo", "" );
             fail( "Expected exception" );
         }
         catch( final IllegalArgumentException e ) {
             // Expected path
         }
     }
 
 
     /***
      *  Test replace() with a variety of inputs
      */
     public void testReplace() {
         final String[][] data = {
                 {"", "", "", ""},
                 {"foo", "bar", "b", "foo"},
                 {"foo bar", "foo", "rhino", "rhino bar"},
                 {"foo bar", "foo", "foo", "foo bar"},
                 {"afoob", "foo", "bar", "abarb"},
                 {"afoobfooc", "foo", "", "abc"},
                 };
 
         for( int i = 0; i < data.length; i++ ) {
             final String source = data[i][0];
             final String oldText = data[i][1];
             final String newText = data[i][2];
             final String expectedResult = data[i][3];
 
             final String description = "StringUtil.replace(\"" + source + "\", \""
                 + oldText + "\", \"" + newText + "\")";
             assertEquals( description, expectedResult, StringUtil.replace( source, oldText, newText ) );
         }
     }
 }