Logo Search packages:      
Sourcecode: mauve version File versions  Download package

StringTest.java

/* Copyright (C) 1999 Hewlett-Packard Company

   This file is part of Mauve.

   Mauve is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   Mauve is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with Mauve; see the file COPYING.  If not, write to
   the Free Software Foundation, 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.
*/

// Tags: JDK1.0

package gnu.testlet.java.lang.String;
import gnu.testlet.Testlet;
import gnu.testlet.TestHarness;

public class StringTest implements Testlet
{

  protected static TestHarness harness;
      public void test_Basics()
      {
            String str1 = new String();
            harness.check(!( str1.length() != 0 ),  
                  "test_Basics - 1");
            harness.check(!( !str1.toString().equals("")), 
                  "test_Basics - 2");

            String str2 = new String("testing" );
            harness.check(!( str2.length() != 7 ),  
                  "test_Basics - 3");
            harness.check(!( !str2.toString().equals("testing")), 
                  "test_Basics - 4");

            
            try {
                  String str = null;
                  String str3 = new String(str);
                  harness.fail("test_Basics - 5");
            }
            catch ( NullPointerException e ){}  

            String str4 = new String( new StringBuffer("hi there"));
            harness.check(!( str4.length () != 8 ),  
                  "test_Basics - 6");
            harness.check(!( !str4.toString().equals("hi there")), 
                  "test_Basics - 7");

            char cdata[] = { 'h' , 'e' , 'l' , 'l' , 'o' };
            String str5 = new String( cdata );
            harness.check(!( str5.length () != 5 ),  
                  "test_Basics - 8");
            harness.check(!( !str5.toString().equals("hello")), 
                  "test_Basics - 9");

            try {
                  String str6 = new String( cdata , 0 , 10 );
                  harness.fail("test_Basics - 10");

            }catch ( IndexOutOfBoundsException e )
            {}

            try {
                  byte [] barr = null;
                  String str7 = new String( barr , 0 , 10 );
                  harness.fail("test_Basics - 11");

            }catch ( NullPointerException e )
            {}

            String str8 = new String( cdata , 0 , 4 );
            harness.check(!( !str8.equals("hell")), 
                  "test_Basics - 12");

            try {
                  String str10 = new String( null , 10 );
                  harness.fail("test_Basics - 13");

            }catch ( NullPointerException e )
            {}

            byte bdata[] = { (byte)'d',(byte)'a',(byte)'n',(byte)'c',(byte)'i',(byte)'n',(byte)'g' };
            String str9 = new String(bdata , 10 );

            char ch = str9.charAt(1);
            int i = (ch & 0xff00 ) >> 8 ;
            byte b = (byte)(ch & 0x00ff );

            harness.check(!( i != 10 ||  b != 'a' ), 
                  "test_Basics - 14");
            

            byte bnull [] = null;
            try {
                  String str11 = new String( bnull , 10 , 0 , 5);
                  harness.fail("test_Basics - 15");
            }catch ( NullPointerException e ){}

            try {
                  String str12 = new String( bdata , 10 , -1 , 3);
                  harness.fail("test_Basics - 16");
            }catch ( IndexOutOfBoundsException  e ){}


            String str13 = new String( bdata , 10 , 1 , 1 );
            i = (ch & 0xff00 ) >> 8 ;
            b = (byte)(ch & 0x00ff );

            harness.check(!( i != 10 ||  b != 'a' ), 
                  "test_Basics - 17");

            String str14 = new String( bdata);
            harness.check(!( !str14.equals("dancing")), 
                  "test_Basics - 18");

            // EJWcr00461
            byte arr[]={(byte)'a'};
            String str15 = new String(arr,0x1234,0,1);
            if (!str15.equals("\u3461")) {
                harness.fail("test_Basics - 19");
            }

            // EJWcr00462
            char carr[] = {'h','e','l','l','o'};
            try {
                String str16 = new String(carr, Integer.MAX_VALUE, 1);
                harness.fail("test_Basics - 20");
            } catch (IndexOutOfBoundsException e) {
            }
            byte arr2[]={(byte)'a', (byte)'b', (byte)'c', (byte)'d', (byte)'e'};
            try {
                String str17 = new String(arr2,0x1234,Integer.MAX_VALUE,1);
                harness.fail("test_Basics - 21");
            } catch (IndexOutOfBoundsException e) {
            }
                         
            // this used to cause the vm to core dump (cr543)
            String s = "\u0d3e";

      }

      public void test_toString()
      {
            String str1 = "218943289";

            harness.check(!( !str1.toString().equals("218943289")), 
                  "test_toString - 1");

            harness.check(!( str1 != "218943289" ), 
                  "test_toString - 2");

            harness.check(!( !str1.equals(str1.toString())), 
                  "test_toString - 3");         
      }

      public void test_equals()
      {
            String str2 = new String("Nectar");

            harness.check(!( str2.equals( null )), 
                  "test_equals - 1");           

            harness.check(!( !str2.equals("Nectar")), 
                  "test_equals - 2");           

            harness.check(!( str2.equals("")), 
                  "test_equals - 3");           

            harness.check(!( str2.equals("nectar")), 
                  "test_equals - 4");           

            harness.check(!( !"".equals("")), 
                  "test_equals - 5");           

      }

      public void test_hashCode()
      {
            String str1 = "hp";
            String str2 = "Hewlett Packard Company";

            int hash1 = 'h' * 31 + 'p';
            int acthash1 = str1.hashCode(); 

            harness.check(!( hash1 != acthash1 ), 
                  "test_hashCode - 1");         
      }

      public void test_length()
      {
            harness.check(!( "".length() != 0 ),  
                  "test_length - 1");
            
            harness.check(!( "pentium".length() != 7 ),  
                  "test_length - 2");
      }

      public void test_charAt()
      {
            harness.check(!( "abcd".charAt(0) != 'a' || "abcd".charAt(1) != 'b' ||
                   "abcd".charAt(2) != 'c' || "abcd".charAt(3) != 'd'   ), 
                  "test_charAt - 1");

            try {
                  char ch = "abcd".charAt(4);
                  harness.fail("test_charAt - 2");
            }
            catch ( IndexOutOfBoundsException e ){}

            try {
                  char ch = "abcd".charAt(-1);
                  harness.fail("test_charAt - 3");
            }
            catch ( IndexOutOfBoundsException e ){}
      }

      public void test_getChars()
      {
            String str = "abcdefghijklmn";

            try {
                  str.getChars(0 , 3 , null , 1 );
                  harness.fail("test_getChars - 1");
            }catch ( NullPointerException e ){}

            char dst[] = new char[5];
            
            try {
                  str.getChars(-1 , 3 , dst , 1 );
                  harness.fail("test_getChars - 2");
            }catch ( IndexOutOfBoundsException e ){}

            try {
                  str.getChars(4 , 3 , dst , 1 );
                  harness.fail("test_getChars - 3");
            }catch ( IndexOutOfBoundsException e ){}

            try {
                  str.getChars(1 , 15 , dst , 1 );
                  harness.fail("test_getChars - 4");
            }catch ( IndexOutOfBoundsException e ){}

            try {
                  str.getChars(1 , 5 , dst , -1 );
                  harness.fail("test_getChars - 5");
            }catch ( IndexOutOfBoundsException e ){}

            try {
                  str.getChars(1 , 10 , dst , 1 );
                  harness.fail("test_getChars - 6");
            }catch ( IndexOutOfBoundsException e ){}

            str.getChars(0,5,dst, 0 );
            harness.check(!( dst[0] != 'a' || dst[1] != 'b' || dst[2] != 'c' ||
                                            dst[3] != 'd' || dst[4] != 'e' ), 
                  "test_getChars - 7");

            dst[0] = dst[1] = dst[2] = dst[3] = dst[4] = ' ';
            str.getChars(0,0,dst, 0 );
            harness.check(!( dst[0] != ' ' || dst[1] != ' ' || dst[2] != ' ' ||
                                            dst[3] != ' ' || dst[4] != ' ' ), 
                  "test_getChars - 9");

            dst[0] = dst[1] = dst[2] = dst[3] = dst[4] = ' ';
            str.getChars(0,1,dst, 0 );
            harness.check(!( dst[0] != 'a' || dst[1] != ' ' || dst[2] != ' ' ||
                                            dst[3] != ' ' || dst[4] != ' ' ), 
                  "test_getChars - 10");
      }


      public void test_getBytes()
      {
            String str = "abcdefghijklmn";

            try {
                  str.getBytes(0 , 3 , null , 1 );
                  harness.fail("test_getBytes - 1");
            }catch ( NullPointerException e ){}

            byte dst[] = new byte[5];
            
            try {
                  str.getBytes(-1 , 3 , dst , 1 );
                  harness.fail("test_getBytes - 2");
            }catch ( IndexOutOfBoundsException e ){}

            try {
                  str.getBytes(4 , 3 , dst , 1 );
                  harness.fail("test_getBytes - 3");
            }catch ( IndexOutOfBoundsException e ){}

            try {
                  str.getBytes(1 , 15 , dst , 1 );
                  harness.fail("test_getBytes - 4");
            }catch ( IndexOutOfBoundsException e ){}

            try {
                  str.getBytes(1 , 5 , dst , -1 );
                  harness.fail("test_getBytes - 5");
            }catch ( IndexOutOfBoundsException e ){}

            try {
                  str.getBytes(1 , 10 , dst , 1 );
                  harness.fail("test_getBytes - 6");
            }catch ( IndexOutOfBoundsException e ){}

            str.getBytes(0,5,dst, 0 );
            harness.check(!( dst[0] != 'a' || dst[1] != 'b' || dst[2] != 'c' ||
                                            dst[3] != 'd' || dst[4] != 'e' ), 
                  "test_getBytes - 7");

            byte [] dst1 = new byte[40];
            dst1 = str.getBytes();
            harness.check(!( dst1[0] != 'a' || dst1[1] != 'b' || dst1[2] != 'c' ||
                                            dst1[3] != 'd' || dst1[4] != 'e' ), 
                  "test_getBytes - 8");
      }

      public void test_toCharArray()
      {
            char[] charr = "abcde".toCharArray();

            harness.check(!( charr[0] != 'a' || charr[1] != 'b' ||
                  charr[2] != 'c' || charr[3] != 'd' ||
                  charr[4] != 'e' ), 
                  "test_toCharArray - 1");

            char [] charr1 = "".toCharArray();

            harness.check(!( charr1.length  > 0 ), 
                  "test_toCharArray - 2");
      }

      public void test_equalsIgnoreCase()
      {
            harness.check(!( "hi".equalsIgnoreCase(null)), 
                  "test_equalsIgnoreCase - 1");

            harness.check(!( !"hi".equalsIgnoreCase("HI")), 
                  "test_equalsIgnoreCase - 2");

            harness.check(!( "hi".equalsIgnoreCase("pq")), 
                  "test_equalsIgnoreCase - 3");

            harness.check(!( "hi".equalsIgnoreCase("HI ")), 
                  "test_equalsIgnoreCase - 4");

      }

      public void test_compareTo()
      {
            try {
                  int res = "abc".compareTo(null);
                  harness.fail("test_compareTo - 1");
            }
            catch ( NullPointerException e ){}

            harness.check(!( "abc".compareTo("bcdef") >= 0  ), 
                  "test_compareTo - 2");

            harness.check(!( "abc".compareTo("abc") != 0 ), 
                  "test_compareTo - 3");

            harness.check(!( "abc".compareTo("aabc") <= 0 ), 
                  "test_compareTo - 4");

            harness.check(!( "abcd".compareTo("abc") <= 0 ), 
                  "test_compareTo - 5");

            harness.check(!( "".compareTo("abc") >= 0 ), 
                  "test_compareTo - 6");
      }

      public void test_regionMatches()
      {
            try {
                  boolean res = "abc".regionMatches(0 , null , 0 , 2);
                  harness.fail("test_regionMatches - 1");
            }
            catch ( NullPointerException e ){}

            harness.check(!( "abcd".regionMatches(-1 , "abcd" , 0 , 2 )), 
                  "test_regionMatches - 2");
            harness.check(!( "abcd".regionMatches(0 , "abcd" , - 1 , 2 )), 
                  "test_regionMatches - 3");
            harness.check(!( "abcd".regionMatches(0 , "abcd" , 0 , 10 )), 
                  "test_regionMatches - 4");
            harness.check(!( "abcd".regionMatches(0 , "ab" , 0 , 3 )), 
                  "test_regionMatches - 5");

            harness.check(!( !"abcd".regionMatches(1 , "abc" , 1 , 2 )), 
                  "test_regionMatches - 6");

            harness.check(!( !"abcd".regionMatches(1 , "abc" , 1 , 0 )), 
                  "test_regionMatches - 7");

            harness.check(!( "abcd".regionMatches(1 , "ABC" , 1 , 2 )), 
                  "test_regionMatches - 8");
            

            try {
                  boolean res = "abc".regionMatches(true , 0 , null , 0 , 2);
                  harness.fail("test_regionMatches - 11");
            }
            catch ( NullPointerException e ){}

            harness.check(!( "abcd".regionMatches(true , -1 , "abcd" , 0 , 2 )), 
                  "test_regionMatches - 12");
            harness.check(!( "abcd".regionMatches(true , 0 , "abcd" , - 1 , 2 )), 
                  "test_regionMatches - 13");
            harness.check(!( "abcd".regionMatches(true , 0 , "abcd" , 0 , 10 )), 
                  "test_regionMatches - 14");
            harness.check(!( "abcd".regionMatches(true , 0 , "ab" , 0 , 3 )), 
                  "test_regionMatches - 15");

            harness.check(!( !"abcd".regionMatches(true , 1 , "abc" , 1 , 2 )), 
                  "test_regionMatches - 16");

            harness.check(!( !"abcd".regionMatches(true , 1 , "abc" , 1 , 0 )), 
                  "test_regionMatches - 17");

            harness.check(!( !"abcd".regionMatches(true , 1 , "ABC" , 1 , 2 )), 
                  "test_regionMatches - 18");
            harness.check(!( "abcd".regionMatches(false , 1 , "ABC" , 1 , 2 )), 
                  "test_regionMatches - 19");
      }

      public void test_startsWith()
      {
            harness.check(!( !"abcdef".startsWith( "abc")), 
                  "test_startsWith - 1");

            try {
                  boolean b = "abcdef".startsWith( null );
                  harness.fail("test_startsWith - 2");
            } catch ( NullPointerException e ){}

            harness.check(!( "abcdef".startsWith( "ABC")), 
                  "test_startsWith - 3");

            harness.check(!( !"abcdef".startsWith( "")), 
                  "test_startsWith - 4");

            harness.check(!( "abc".startsWith( "abcd")), 
                  "test_startsWith - 5");


            harness.check(!( !"abcdef".startsWith( "abc" , 0 )), 
                  "test_startsWith - 6");

            try {
                  boolean b = "abcdef".startsWith( null ,0);
                  harness.fail("test_startsWith - 7");
            } catch ( NullPointerException e ){}

            harness.check(!( "abcdef".startsWith( "ABC", 2)), 
                  "test_startsWith - 8");

            harness.check(!( !"abcdef".startsWith( "", 0 )), 
                  "test_startsWith - 9");

            harness.check(!( "abc".startsWith( "abcd" , 3)), 
                  "test_startsWith - 10");

            harness.check(!( "abc".startsWith( "abc" , 10)), 
                  "test_startsWith - 11");
      }

      public void test_endsWith()
      {
            harness.check(!( !"abcdef".endsWith( "def")), 
                  "test_endsWith - 1");

            try {
                  boolean b = "abcdef".endsWith( null );
                  harness.fail("test_endsWith - 2");
            } catch ( NullPointerException e ){}

            harness.check(!( "abcdef".endsWith( "DEF")), 
                  "test_endsWith - 3");

            harness.check(!( !"abcdef".endsWith( "")), 
                  "test_endsWith - 4");

            harness.check(!( "bcde".endsWith( "abcd")), 
                  "test_endsWith - 5");

      }

      public void test_indexOf()
      {
            harness.check(!( "a".indexOf('a') != 0 ), 
                  "test_indexOf - 1");

            harness.check(!( "aabc".indexOf('c') != 3 ), 
                  "test_indexOf - 2");

            harness.check(!( "a".indexOf('c') != -1 ), 
                  "test_indexOf - 3");

            harness.check(!( "".indexOf('a') != -1 ), 
                  "test_indexOf - 4");


            harness.check(!( "abcde".indexOf('b', 3) != -1 ), 
                  "test_indexOf - 5");
            harness.check(!( "abcde".indexOf('b', 0) != 1 ), 
                  "test_indexOf - 6");
            harness.check(!( "abcdee".indexOf('e', 3) != 4 ), 
                  "test_indexOf - 7");
            harness.check(!( "abcdee".indexOf('e', 5) != 5 ), 
                  "test_indexOf - 8");

            harness.check(!( "abcdee".indexOf('e', -5) != 4 ), 
                  "test_indexOf - 9");
            harness.check(!( "abcdee".indexOf('e', 15) != -1 ), 
                  "test_indexOf - 10");


            harness.check(!( "abcdee".indexOf("babu") != -1 ), 
                  "test_indexOf - 11");
            try {
                  int x = "abcdee".indexOf(null);
                  harness.fail("test_indexOf - 12");
            }catch ( NullPointerException e ){} 
      
            harness.check(!( "abcdee".indexOf("") != 0 ), 
                  "test_indexOf - 13");
            harness.check(!( "abcdee".indexOf("ee") != 4 ), 
                  "test_indexOf - 14");
            harness.check(!( "abcbcbc".indexOf("cbc") != 2 ), 
                  "test_indexOf - 15");

            harness.check(!( "abcdee".indexOf("babu", 3) != -1 ), 
                  "test_indexOf - 16");
            try {
                  int x = "abcdee".indexOf(null,0);
                  harness.fail("test_indexOf - 17");
            }catch ( NullPointerException e ){} 
      
            harness.check(!( "abcdee".indexOf("", 0) != 0 ), 
                  "test_indexOf - 18");
            harness.check(!( "abcdee".indexOf("ee", 4) != 4 ), 
                  "test_indexOf - 19");
            harness.check(!( "abcbcbc".indexOf("cbc",4 ) != 4 ), 
                  "test_indexOf - 20");
            // EJWcr00463
            if ( "hello \u5236 world".indexOf('\u5236') != 6 ) {
                  harness.fail("test_indexOf - 21");
            }
            if ( "hello \u0645 world".indexOf('\u0645') != 6 ) {
                  harness.fail("test_indexOf - 22");
            }
            if ( "hello \u07ff world".indexOf('\u07ff') != 6 ) {
                  harness.fail("test_indexOf - 23");
            }
      }

      public void test_lastIndexOf()
      {
            harness.check(!( "a".lastIndexOf('a') != 0 ), 
                  "test_lastIndexOf - 1");

            harness.check(!( "aabc".lastIndexOf('c') != 3 ), 
                  "test_lastIndexOf - 2");

            harness.check(!( "a".lastIndexOf('c') != -1 ), 
                  "test_lastIndexOf - 3");

            harness.check(!( "".lastIndexOf('a') != -1 ), 
                  "test_lastIndexOf - 4");


            harness.check(!( "abcde".lastIndexOf('b', 0) != -1 ), 
                  "test_lastIndexOf - 5");
            harness.check(!( "abcde".lastIndexOf('b', 4) != 1 ), 
                  "test_lastIndexOf - 6");
            harness.check(!( "abcdee".lastIndexOf('e', 7) != 5 ), 
                  "test_lastIndexOf - 7");
            harness.check(!( "abcdee".lastIndexOf('e', 5) != 5 ), 
                  "test_lastIndexOf - 8");

            harness.check(!( "abcdee".lastIndexOf('e', -5) != -1 ), 
                  "test_lastIndexOf - 9");
            harness.check(!( "abcdee".lastIndexOf('e', 15) != 5 ), 
                  "test_lastIndexOf - 10");


            harness.check(!( "abcdee".lastIndexOf("babu") != -1 ), 
                  "test_lastIndexOf - 11");
            try {
                  int x = "abcdee".lastIndexOf(null);
                  harness.fail("test_lastIndexOf - 12");
            }catch ( NullPointerException e ){} 
      
            harness.check(!( "abcdee".lastIndexOf("") != 6 ), 
                  "test_lastIndexOf - 13");
            harness.check(!( "abcdee".lastIndexOf("ee") != 4 ), 
                  "test_lastIndexOf - 14");
            harness.check(!( "abcbcbc".lastIndexOf("cbc") != 4 ), 
                  "test_lastIndexOf - 15");

            harness.check(!( "abcdee".lastIndexOf("babu", 3) != -1 ), 
                  "test_lastIndexOf - 16");

            try {
                  int x = "abcdee".lastIndexOf(null,0);
                  harness.fail("test_lastIndexOf - 17");
            }catch ( NullPointerException e ){} 
      
            harness.check(!( "abcdee".lastIndexOf("", 0) != 0 ), 
                  "test_lastIndexOf - 18");
            harness.check(!( "abcdee".lastIndexOf("ee", 4) != 4 ), 
                  "test_lastIndexOf - 19");
            harness.check(!( "abcbcbc".lastIndexOf("cbc",3 ) != 2 ), 
                  "test_lastIndexOf - 20");
      }

      public void test_substring()
      {
            harness.check(!( !"unhappy".substring(2).equals("happy")), 
                  "test_substring - 1");
            harness.check(!( !"Harbison".substring(3).equals("bison")), 
                  "test_substring - 2");
            harness.check(!( !"emptiness".substring(9).equals("")), 
                  "test_substring - 3");

            try {
                  String str = "hi there".substring(-1);
                  harness.fail("test_substring - 4");
            }catch( IndexOutOfBoundsException e ){}

            try {
                  String str = "hi there".substring(10);
                  harness.fail("test_substring - 5");
            }catch( IndexOutOfBoundsException e ){}


            harness.check(!( !"hamburger".substring(4,8).equals("urge")), 
                  "test_substring - 6");
            harness.check(!( !"smiles".substring(1,5).equals("mile")), 
                  "test_substring - 7");
            harness.check(!( !"emptiness".substring(2,2).equals("")), 
                  "test_substring - 8");

            try {
                  String str = "hi there".substring(-1, 3);
                  harness.fail("test_substring - 9");
            }catch( IndexOutOfBoundsException e ){}

            try {
                  String str = "hi there".substring(0, 10);
                  harness.fail("test_substring - 10");
            }catch( IndexOutOfBoundsException e ){}

            try {
                  String str = "hi there".substring(7, 6);
                  harness.fail("test_substring - 11");
            }catch( IndexOutOfBoundsException e ){}


      }

      public void test_concat( )
      {
            try {
                  String str = "help".concat(null);
                  harness.fail("test_concat - 1");
            }catch ( NullPointerException e){}

            harness.check(!( !"help".concat("me").equals("helpme")), 
                  "test_concat - 2");

            harness.check(!( ! "to".concat("get").concat("her").equals("together")), 
                  "test_concat - 3");

            harness.check(!( "hi".concat("") != "hi"), 
                  "test_concat - 4");

            String str1 = "".concat("there");
            harness.check(!( !str1.equals("there")), 
                  "test_concat - 5");

            // EJWcr00467
            String str2 = new String();
            try {
                str2 = str2.concat("hello");
                if (!str2.equals("hello")) {
                  harness.fail("test_concat - 7");
                }
            } catch (Exception e) {
                  harness.fail("test_concat - 6");
            }
      }


      public void test_replace()
      {
            harness.check(!( !"mesquite in your cellar".replace('e' , 'o' ).equals(
                            "mosquito in your collar" )), 
                  "test_replace - 1");

            harness.check(!( !"the war of baronets".replace('r' , 'y' ).equals(
                            "the way of bayonets" )), 
                  "test_replace - 2");

            harness.check(!( !"sparring with a purple porpoise".replace('p' , 't' ).equals(
                            "starring with a turtle tortoise" )), 
                  "test_replace - 3");

            harness.check(!( !"JonL".replace('q' , 'x' ).equals("JonL" )), 
                  "test_replace - 4");

            harness.check(!( !"ppppppppppppp".replace('p' , 'p' ).equals("ppppppppppppp")), 
                  "test_replace - 5");

            harness.check(!( !"ppppppppppppp".replace('p' , '1' ).equals("1111111111111")), 
                  "test_replace - 6");
            harness.check(!( !"hp".replace('c' , 'd' ).equals("hp")), 
                  "test_replace - 7");
            harness.check(!( !"vmhere".replace('a' , 'd' ).equals("vmhere")), 
                  "test_replace - 8");


      }

      public void test_toLowerCase()
      {
            harness.check(!( !"".toLowerCase().equals("")), 
                  "test_toLowerCase - 1");

            harness.check(!( !"French Fries".toLowerCase().equals("french fries")), 
                  "test_toLowerCase - 2");


            harness.check(!( !"SMALL-VM".toLowerCase().equals("small-vm")), 
                  "test_toLowerCase - 3");
      }

      public void test_toUpperCase()
      {
            harness.check(!( !"".toUpperCase().equals("")), 
                  "test_toUpperCase - 1");

            harness.check(!( !"French Fries".toUpperCase().equals("FRENCH FRIES")), 
                  "test_toUpperCase - 2");


            harness.check(!( !"SMALL-VM".toUpperCase().equals("SMALL-VM")), 
                  "test_toUpperCase - 3");

            harness.check(!( !"small-jvm".toUpperCase().equals("SMALL-JVM")), 
                  "test_toUpperCase - 4");
      }


      public void test_valueOf()
      {
            harness.check(!( !String.valueOf((Object)null).equals("null")), 
                  "test_valueOf - 1");

            Object obj = new Object();
            harness.check(!( !String.valueOf(obj).equals(obj.toString())), 
                  "test_valueOf - 2");


            try {
                  char [] data = null;
                  String str = String.valueOf( data );
            }catch ( NullPointerException e ){}

            char [] data = { 'h' , 'e' , 'l' , 'l' , 'o' };
            harness.check(!( !String.valueOf( data ).equals("hello")), 
                  "test_valueOf - 3");

            harness.check(!( !String.copyValueOf( data ).equals("hello")), 
                  "test_valueOf - 3a");

            try {
                  String str = String.valueOf(data , -1 , 4 );
                  harness.fail("test_valueOf - 4");
            }catch ( IndexOutOfBoundsException e ){}

            try {
                  String str = String.valueOf(data , 1 , 5 );
                  harness.fail("test_valueOf - 5");
            }catch ( IndexOutOfBoundsException e ){}

            try {
                  String str = String.valueOf(data , 1 , -5 );
                  harness.fail("test_valueOf - 6");
            }catch ( IndexOutOfBoundsException e ){}

            try {
                  String str = String.valueOf(null , 1 , 3 );
                  harness.fail("test_valueOf - 7");
            }catch ( NullPointerException e ){}

            harness.check(!( !String.valueOf(data , 2 , 2 ).equals("ll")), 
                  "test_valueOf - 8");

            harness.check(!( !String.copyValueOf(data , 2 , 2 ).equals("ll")), 
                  "test_valueOf - 8a");

            harness.check(!( !String.valueOf(true).equals("true")), 
                  "test_valueOf - 9");

            harness.check(!( !String.valueOf(false).equals("false")), 
                  "test_valueOf - 10");

            harness.check(!( !String.valueOf('c').equals("c")), 
                  "test_valueOf - 11");

            harness.check(!( !String.valueOf(' ').equals(" ")), 
                  "test_valueOf - 12");

            harness.check(!( !String.valueOf(234).equals("234")), 
                  "test_valueOf - 13");

            harness.check(!( !String.valueOf(234L).equals("234")), 
                  "test_valueOf - 14");

            harness.check(!( !String.valueOf(23.45f).equals("23.45")), 
                  "test_valueOf - 15");

            harness.check(!( !String.valueOf(23.4).equals("23.4")), 
                  "test_valueOf - 16");
      }
        
        public void test_intern()
      {
            String hp = "hp";
            String nullstr = "";
            harness.check(!( "hp".intern() != hp.intern()), 
                  "test_intern - 1");
            harness.check(!( "pqr".intern() == hp.intern()), 
                  "test_intern - 2");
            harness.check(!( "".intern() != nullstr.intern()), 
                  "test_intern - 3");
            harness.check(!( "".intern() == hp.intern()), 
                  "test_intern - 4");
            hp = "";
            harness.check(!( "".intern() != hp.intern()), 
                  "test_intern - 5");
            StringBuffer buff= new StringBuffer();
            buff.append('a');
            buff.append('b');
            harness.check(!( "ab".intern() != buff.toString().intern()), 
                  "test_intern - 6");
            StringBuffer buff1 = new StringBuffer();
            harness.check(!( "".intern() != buff1.toString().intern()), 
                  "test_intern - 7");

      }
      public void test_trim()
      {
          String source = "   laura";
          String dest;

          dest = source.trim();
          if (!dest.equals("laura")) {
            harness.fail("Error - test_trim - 1");
            System.out.println("expected 'laura', got '" + dest + "'");
          }

          source = "                laura";
          dest = source.trim();
          if (!dest.equals("laura")) {
            harness.fail("Error - test_trim - 2");
            System.out.println("expected 'laura', got '" + dest + "'");
          }

          source = "              ";
          dest = source.trim();
          if (!dest.equals("")) {
            harness.fail("Error - test_trim - 3");
            System.out.println("expected '', got '" + dest + "'");
          }
          source = "laura";
          dest = source.trim();
          if (dest != source) {
            harness.fail("Error - test_trim - 4");
            System.out.println("Expected strings to be equal");
          }
          source = "l        ";
          dest = source.trim();
          if (!dest.equals("l")) {
            harness.fail("Error - test_trim - 5");
            System.out.println("expected 'l', got '" + dest + "'");
          }
          source = "           l";
          dest = source.trim();
          if (!dest.equals("l")) {
            harness.fail("Error - test_trim - 6");
            System.out.println("expected 'l', got '" + dest + "'");
          }
          source = "           l            ";
          dest = source.trim();
          if (!dest.equals("l")) {
            harness.fail("Error - test_trim - 7");
            System.out.println("expected 'l', got '" + dest + "'");
          }
          source = "           l a u r a             ";
          dest = source.trim();
          if (!dest.equals("l a u r a")) {
            harness.fail("Error - test_trim - 8");
            System.out.println("expected 'l a u r a', got '" + dest + "'");
          }
      }

      public void testall()
      {
            test_Basics();
            test_toString();
            test_equals();
            test_hashCode();
            test_length();
            test_charAt();
            test_getChars();
            test_getBytes();  
            test_toCharArray();
            test_equalsIgnoreCase();
            test_compareTo();
            test_regionMatches();
            test_startsWith();
            test_endsWith();
            test_indexOf();
            test_lastIndexOf();
            test_substring();
            test_concat();
            test_replace();
            test_toLowerCase();
            test_toUpperCase();
            test_valueOf();
            test_intern();
            test_trim();
      }


  public void test (TestHarness the_harness)
  {
    harness = the_harness;
    testall ();
  }

}

Generated by  Doxygen 1.6.0   Back to index