user/test/com/google/gwt/emultest/java/lang/CompilerConstantStringTest.java - gwt - Git at Google

 /*
  * Copyright 2008 Google Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * License for the specific language governing permissions and limitations under
  * the License.
  */
 package com.google.gwt.emultest.java.lang;

 import com.google.gwt.core.shared.impl.StringCase;
 import com.google.gwt.junit.client.GWTTestCase;

 /**
  * This test verifies that the static evaluation performed by the compiler
  * on constant string expressions is correct.
  *
  * TODO: this is just copied from the old StringTest before it was improved,
  *     but we need to go through and remove tests that do not actually
  *     test the compiler.
  */
 public class CompilerConstantStringTest extends GWTTestCase {

   @Override
   public String getModuleName() {
     return "com.google.gwt.emultest.EmulSuite";
   }

   public void testCharAt() {
     assertEquals("abc".charAt(1), 'b');
   }

   public void testConcat() {
     assertEquals("abcdef", "abc" + "def");
     assertEquals("abcdef", "abc".concat("def"));
     assertEquals("".concat(""), "");
     char c = 'd';
     String s = "abc";
     assertEquals("abcd", "abc" + 'd');
     assertEquals("abcd", "abc" + c);
     assertEquals("abcd", s + 'd');
     assertEquals("abcd", s + c);
     s += c;
     assertEquals("abcd", s);
   }

   public void testConstructor() {
     char[] chars = {'a', 'b', 'c', 'd', 'e', 'f'};
     String constant = "abcdef";
     String shortString = "cde";
     assertEquals(new String(constant), constant);
     assertEquals(new String(chars), constant);
     assertEquals(new String(chars, 2, 3), shortString);
     assertEquals(new String(""), "");
     assertEquals(new String(new String(new String(new String("")))), "");
     assertEquals(new String(new char[] {}), "");
   }

   public void testContains() {
     // at the beginning
     assertTrue("abcdef".contains("ab"));
     assertTrue("abcdef".contains(new StringBuffer("ab")));
     // at the end
     assertTrue("abcdef".contains("ef"));
     assertTrue("abcdef".contains(new StringBuffer("ef")));
     // in the middle
     assertTrue("abcdef".contains("cd"));
     assertTrue("abcdef".contains(new StringBuffer("cd")));
     // the same
     assertTrue("abcdef".contains("abcdef"));
     assertTrue("abcdef".contains(new StringBuffer("abcdef")));
     // not present
     assertFalse("abcdef".contains("z"));
     assertFalse("abcdef".contains(new StringBuffer("z")));
   }

   public void testEndsWith() {
     String haystack = "abcdefghi";
     assertTrue("a", haystack.endsWith("defghi"));
     assertTrue("b", haystack.endsWith(haystack));
     assertFalse("c", haystack.endsWith(haystack + "j"));
   }

   public void testEquals() {
     assertFalse("ABC".equals("abc"));
     assertFalse("abc".equals("ABC"));
     assertTrue("abc".equals("abc"));
     assertTrue("ABC".equals("ABC"));
     assertFalse("AbC".equals("aBC"));
     assertFalse("AbC".equals("aBC"));
     assertTrue("".equals(""));
     assertFalse("".equals(null));
   }

   public void testEqualsIgnoreCase() {
     assertTrue("ABC".equalsIgnoreCase("abc"));
     assertTrue("abc".equalsIgnoreCase("ABC"));
     assertTrue("abc".equalsIgnoreCase("abc"));
     assertTrue("ABC".equalsIgnoreCase("ABC"));
     assertTrue("AbC".equalsIgnoreCase("aBC"));
     assertTrue("AbC".equalsIgnoreCase("aBC"));
     assertTrue("".equalsIgnoreCase(""));
     assertFalse("".equalsIgnoreCase(null));
   }

   /**
    * Tests hashing with strings.
    *
    * The specific strings used in this test used to trigger failures because we
    * use a JavaScript object as a hash map to cache the computed hash codes.
    * This conflicts with built-in properties defined on objects -- see issue
    * #631.
    *
    */
   public void testHashCode() {
     String[] testStrings = {
         "watch", "unwatch", "toString", "toSource", "eval", "valueOf",
         "constructor", "__proto__"};
     int[] savedHash = new int[testStrings.length];
     for (int i = 0; i < testStrings.length; ++i) {
       savedHash[i] = testStrings[i].hashCode();

       /*
        * Verify that the resulting hash code is numeric, since this is not
        * enforced in Production Mode.
        */
       String str = Integer.toString(savedHash[i]);
       for (int j = 0; j < str.length(); ++j) {
         char ch = str.charAt(j);
         assertTrue("Bad character '" + ch + "' (U+0" + Integer.toHexString(ch)
             + ")", ch == '-' || ch == ' ' || Character.isDigit(ch));
       }
     }
     // verify the hash codes are constant for a given string
     for (int i = 0; i < testStrings.length; ++i) {
       assertEquals(savedHash[i], testStrings[i].hashCode());
     }
   }

   public void testIndexOf() {
     String haystack = "abcdefghi";
     assertEquals(haystack.indexOf("q"), -1);
     assertEquals(haystack.indexOf('q'), -1);
     assertEquals(haystack.indexOf("a"), 0);
     assertEquals(haystack.indexOf('a'), 0);
     assertEquals(haystack.indexOf('a', 1), -1);
     assertEquals(haystack.indexOf("bc"), 1);
     assertEquals(haystack.indexOf(""), 0);
   }

   public void testLastIndexOf() {
     String x = "abcdeabcdef";
     assertEquals(9, x.lastIndexOf("e"));
     assertEquals(10, x.lastIndexOf("f"));
     assertEquals(-1, x.lastIndexOf("f", 1));
   }

   public void testLength() {
     assertEquals(3, "abc".length());
     String str = "x";
     for (int i = 0; i < 16; i++) {
       str = str + str;
     }
     assertEquals(1 << 16, str.length());
   }

   public void testLowerCase() {
     assertEquals("abc", StringCase.toLower("AbC"));
     assertEquals("abc", StringCase.toLower("abc"));
     assertEquals("", StringCase.toLower(""));
   }

   public void testMatch() {
     assertFalse("1f", "abbbbcd".matches("b*"));
     assertFalse("2f", "abbbbcd".matches("b+"));
     assertTrue("3t", "abbbbcd".matches("ab*bcd"));
     assertTrue("4t", "abbbbcd".matches("ab+cd"));
     assertTrue("5t", "abbbbcd".matches("ab+bcd"));
     assertFalse("6f", "abbbbcd".matches(""));
     assertTrue("7t", "abbbbcd".matches("a.*d"));
     assertFalse("8f", "abbbbcd".matches("a.*e"));
   }

   public void testNull() {
     assertNull(returnNull());
     /*
      * The ""+ is there because GWT currently does not translate a+b
      * defensively enough to handle the case that both a and b are null.
      * Revisit this test if that is ever changed.
      */
     String a = "" + returnNull() + returnNull();
     assertEquals("nullnull", a);
   }

   public void testReplace() {
     assertEquals("axax".replace('x', 'a'), "aaaa");
     assertEquals("aaaa".replace('x', 'a'), "aaaa");
     for (char from = 32; from < 250; ++from) {
       char to = (char) (from + 5);
       assertEquals(toS(to), toS(from).replace(from, to));
     }
     for (char to = 32; to < 250; ++to) {
       char from = (char) (to + 5);
       assertEquals(toS(to), toS(from).replace(from, to));
     }
     // issue 1480
     assertEquals("example xd", "example xd".replace('\r', ' ').replace('\n', ' '));
     assertEquals("dog food", "dog\u0120food".replace('\u0120', ' '));
     assertEquals("ABABAB", "\u1111B\u1111B\u1111B".replace('\u1111', 'A'));
   }

   public void testReplaceAll() {
     assertEquals("abcdef", "xxxxabcxxdexf".replaceAll("x*", ""));
     assertEquals("1\\1abc123\\123de1234\\1234f", "1abc123de1234f".replaceAll(
         "([1234]+)", "$1\\\\$1"));
     assertEquals("\n  \n", "x  x".replaceAll("x", "\n"));
     assertEquals("x  x", "\n  \n".replaceAll("\\\n", "x"));
     assertEquals("x\"\\", "x".replaceAll("x", "\\x\\\"\\\\"));
     assertEquals("$$x$", "x".replaceAll("(x)", "\\$\\$$1\\$"));
   }

   public void testSplit() {
     compareList("fullSplit", new String[] {"abc", "", "", "de", "f"},
         "abcxxxdexfxx".split("x"));
     compareList("emptyRegexSplit", new String[] {
         "", "a", "b", "c", "x", "x", "d", "e", "x", "f", "x"},
         "abcxxdexfx".split(""));
     compareList("2:", "boo:and:foo".split(":", 2), new String[] {
         "boo", "and:foo"});
     compareList("5:", "boo:and:foo".split(":", 5), new String[] {
         "boo", "and", "foo"});
     compareList("-2:", "boo:and:foo".split(":", -2), new String[] {
         "boo", "and", "foo"});
     compareList("5o", "boo:and:foo".split("o", 5), new String[] {
         "b", "", ":and:f", "", ""});
     compareList("-2o", "boo:and:foo".split("o", -2), new String[] {
         "b", "", ":and:f", "", ""});
     compareList("0o", "boo:and:foo".split("o", 0), new String[] {
         "b", "", ":and:f"});
     compareList("0:", "boo:and:foo".split(":", 0), new String[] {
         "boo", "and", "foo"});
   }

   public void testStartsWith() {
     String haystack = "abcdefghi";
     assertTrue(haystack.startsWith("abc"));
     assertTrue(haystack.startsWith("bc", 1));
     assertTrue(haystack.startsWith(haystack));
     assertFalse(haystack.startsWith(haystack + "j"));
   }

   public void testSubstring() {
     String haystack = "abcdefghi";
     assertEquals("cd", haystack.substring(2, 4));
     assertEquals("bc", "abcdef".substring(1, 3));
     assertEquals("bcdef", "abcdef".substring(1));
   }

   public void testToCharArray() {
     char[] a1 = "abc".toCharArray();
     char[] a2 = new char[] {'a', 'b', 'c'};
     for (int i = 0; i < a1.length; i++) {
       assertEquals(a1[i], a2[i]);
     }
   }

   public void testTrim() {
     trimRightAssertEquals("abc", "   \t abc \n  ");
     trimRightAssertEquals("abc", "abc".trim());
     trimRightAssertSame("abc", "abc");
     String s = '\u0023' + "hi";
     trimRightAssertSame(s, s);
     trimRightAssertEquals("abc", " abc".trim());
     trimRightAssertEquals("abc", "abc ".trim());
     trimRightAssertEquals("", "".trim());
     trimRightAssertEquals("", "   \t ".trim());
   }

   public void testUpperCase() {
     assertEquals("abc", StringCase.toLower("AbC"));
     assertEquals("abc", StringCase.toLower("abc"));
     assertEquals("", StringCase.toLower(""));
   }

   public void testValueOf() {
     assertTrue(String.valueOf(C.FLOAT_VALUE).startsWith(C.FLOAT_STRING));
     assertEquals(C.INT_STRING, String.valueOf(C.INT_VALUE));
     assertEquals(C.LONG_STRING, String.valueOf(C.LONG_VALUE));
     assertTrue(String.valueOf(C.DOUBLE_VALUE).startsWith(C.DOUBLE_STRING));
     assertEquals(C.CHAR_STRING, String.valueOf(C.CHAR_VALUE));
     assertEquals(C.CHAR_ARRAY_STRING, String.valueOf(C.CHAR_ARRAY_VALUE));
     assertEquals(C.CHAR_ARRAY_STRING_SUB, String.valueOf(C.CHAR_ARRAY_VALUE, 1,
         4));
     assertEquals(C.FALSE_STRING, String.valueOf(C.FALSE_VALUE));
     assertEquals(C.TRUE_STRING, String.valueOf(C.TRUE_VALUE));
   }

   /**
    * Helper method for testTrim to avoid compiler optimizations.
    */
   public void trimRightAssertEquals(String left, String right) {
     assertEquals(left, right.trim());
   }

   /**
    * Helper method for testTrim to avoid compiler optimizations.
    */
   public void trimRightAssertSame(String left, String right) {
     assertSame(left, right.trim());
   }

   private void compareList(String category, String[] desired, String[] got) {
     assertEquals(category + " length", desired.length, got.length);
     for (int i = 0; i < desired.length; i++) {
       assertEquals(category + " " + i, desired[i], got[i]);
     }
   }

   private String returnNull() {
     return null;
   }

   private String toS(char from) {
     return Character.toString(from);
   }

 }
	/*
	* Copyright 2008 Google Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License"); you may not
	* use this file except in compliance with the License. You may obtain a copy of
	* the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
	* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
	* License for the specific language governing permissions and limitations under
	* the License.
	*/
	package com.google.gwt.emultest.java.lang;

	import com.google.gwt.core.shared.impl.StringCase;
	import com.google.gwt.junit.client.GWTTestCase;

	/**
	* This test verifies that the static evaluation performed by the compiler
	* on constant string expressions is correct.
	*
	* TODO: this is just copied from the old StringTest before it was improved,
	* but we need to go through and remove tests that do not actually
	* test the compiler.
	*/
	public class CompilerConstantStringTest extends GWTTestCase {

	@Override
	public String getModuleName() {
	return "com.google.gwt.emultest.EmulSuite";
	}

	public void testCharAt() {
	assertEquals("abc".charAt(1), 'b');
	}

	public void testConcat() {
	assertEquals("abcdef", "abc" + "def");
	assertEquals("abcdef", "abc".concat("def"));
	assertEquals("".concat(""), "");
	char c = 'd';
	String s = "abc";
	assertEquals("abcd", "abc" + 'd');
	assertEquals("abcd", "abc" + c);
	assertEquals("abcd", s + 'd');
	assertEquals("abcd", s + c);
	s += c;
	assertEquals("abcd", s);
	}

	public void testConstructor() {
	char[] chars = {'a', 'b', 'c', 'd', 'e', 'f'};
	String constant = "abcdef";
	String shortString = "cde";
	assertEquals(new String(constant), constant);
	assertEquals(new String(chars), constant);
	assertEquals(new String(chars, 2, 3), shortString);
	assertEquals(new String(""), "");
	assertEquals(new String(new String(new String(new String("")))), "");
	assertEquals(new String(new char[] {}), "");
	}

	public void testContains() {
	// at the beginning
	assertTrue("abcdef".contains("ab"));
	assertTrue("abcdef".contains(new StringBuffer("ab")));
	// at the end
	assertTrue("abcdef".contains("ef"));
	assertTrue("abcdef".contains(new StringBuffer("ef")));
	// in the middle
	assertTrue("abcdef".contains("cd"));
	assertTrue("abcdef".contains(new StringBuffer("cd")));
	// the same
	assertTrue("abcdef".contains("abcdef"));
	assertTrue("abcdef".contains(new StringBuffer("abcdef")));
	// not present
	assertFalse("abcdef".contains("z"));
	assertFalse("abcdef".contains(new StringBuffer("z")));
	}

	public void testEndsWith() {
	String haystack = "abcdefghi";
	assertTrue("a", haystack.endsWith("defghi"));
	assertTrue("b", haystack.endsWith(haystack));
	assertFalse("c", haystack.endsWith(haystack + "j"));
	}

	public void testEquals() {
	assertFalse("ABC".equals("abc"));
	assertFalse("abc".equals("ABC"));
	assertTrue("abc".equals("abc"));
	assertTrue("ABC".equals("ABC"));
	assertFalse("AbC".equals("aBC"));
	assertFalse("AbC".equals("aBC"));
	assertTrue("".equals(""));
	assertFalse("".equals(null));
	}

	public void testEqualsIgnoreCase() {
	assertTrue("ABC".equalsIgnoreCase("abc"));
	assertTrue("abc".equalsIgnoreCase("ABC"));
	assertTrue("abc".equalsIgnoreCase("abc"));
	assertTrue("ABC".equalsIgnoreCase("ABC"));
	assertTrue("AbC".equalsIgnoreCase("aBC"));
	assertTrue("AbC".equalsIgnoreCase("aBC"));
	assertTrue("".equalsIgnoreCase(""));
	assertFalse("".equalsIgnoreCase(null));
	}

	/**
	* Tests hashing with strings.
	*
	* The specific strings used in this test used to trigger failures because we
	* use a JavaScript object as a hash map to cache the computed hash codes.
	* This conflicts with built-in properties defined on objects -- see issue
	* #631.
	*
	*/
	public void testHashCode() {
	String[] testStrings = {
	"watch", "unwatch", "toString", "toSource", "eval", "valueOf",
	"constructor", "__proto__"};
	int[] savedHash = new int[testStrings.length];
	for (int i = 0; i < testStrings.length; ++i) {
	savedHash[i] = testStrings[i].hashCode();

	/*
	* Verify that the resulting hash code is numeric, since this is not
	* enforced in Production Mode.
	*/
	String str = Integer.toString(savedHash[i]);
	for (int j = 0; j < str.length(); ++j) {
	char ch = str.charAt(j);
	assertTrue("Bad character '" + ch + "' (U+0" + Integer.toHexString(ch)
	+ ")", ch == '-' \|\| ch == ' ' \|\| Character.isDigit(ch));
	}
	}
	// verify the hash codes are constant for a given string
	for (int i = 0; i < testStrings.length; ++i) {
	assertEquals(savedHash[i], testStrings[i].hashCode());
	}
	}

	public void testIndexOf() {
	String haystack = "abcdefghi";
	assertEquals(haystack.indexOf("q"), -1);
	assertEquals(haystack.indexOf('q'), -1);
	assertEquals(haystack.indexOf("a"), 0);
	assertEquals(haystack.indexOf('a'), 0);
	assertEquals(haystack.indexOf('a', 1), -1);
	assertEquals(haystack.indexOf("bc"), 1);
	assertEquals(haystack.indexOf(""), 0);
	}

	public void testLastIndexOf() {
	String x = "abcdeabcdef";
	assertEquals(9, x.lastIndexOf("e"));
	assertEquals(10, x.lastIndexOf("f"));
	assertEquals(-1, x.lastIndexOf("f", 1));
	}

	public void testLength() {
	assertEquals(3, "abc".length());
	String str = "x";
	for (int i = 0; i < 16; i++) {
	str = str + str;
	}
	assertEquals(1 << 16, str.length());
	}

	public void testLowerCase() {
	assertEquals("abc", StringCase.toLower("AbC"));
	assertEquals("abc", StringCase.toLower("abc"));
	assertEquals("", StringCase.toLower(""));
	}

	public void testMatch() {
	assertFalse("1f", "abbbbcd".matches("b*"));
	assertFalse("2f", "abbbbcd".matches("b+"));
	assertTrue("3t", "abbbbcd".matches("ab*bcd"));
	assertTrue("4t", "abbbbcd".matches("ab+cd"));
	assertTrue("5t", "abbbbcd".matches("ab+bcd"));
	assertFalse("6f", "abbbbcd".matches(""));
	assertTrue("7t", "abbbbcd".matches("a.*d"));
	assertFalse("8f", "abbbbcd".matches("a.*e"));
	}

	public void testNull() {
	assertNull(returnNull());
	/*
	* The ""+ is there because GWT currently does not translate a+b
	* defensively enough to handle the case that both a and b are null.
	* Revisit this test if that is ever changed.
	*/
	String a = "" + returnNull() + returnNull();
	assertEquals("nullnull", a);
	}

	public void testReplace() {
	assertEquals("axax".replace('x', 'a'), "aaaa");
	assertEquals("aaaa".replace('x', 'a'), "aaaa");
	for (char from = 32; from < 250; ++from) {
	char to = (char) (from + 5);
	assertEquals(toS(to), toS(from).replace(from, to));
	}
	for (char to = 32; to < 250; ++to) {
	char from = (char) (to + 5);
	assertEquals(toS(to), toS(from).replace(from, to));
	}
	// issue 1480
	assertEquals("example xd", "example xd".replace('\r', ' ').replace('\n', ' '));
	assertEquals("dog food", "dog\u0120food".replace('\u0120', ' '));
	assertEquals("ABABAB", "\u1111B\u1111B\u1111B".replace('\u1111', 'A'));
	}

	public void testReplaceAll() {
	assertEquals("abcdef", "xxxxabcxxdexf".replaceAll("x*", ""));
	assertEquals("1\\1abc123\\123de1234\\1234f", "1abc123de1234f".replaceAll(
	"([1234]+)", "$1\\\\$1"));
	assertEquals("\n \n", "x x".replaceAll("x", "\n"));
	assertEquals("x x", "\n \n".replaceAll("\\\n", "x"));
	assertEquals("x\"\\", "x".replaceAll("x", "\\x\\\"\\\\"));
	assertEquals("$$x$", "x".replaceAll("(x)", "\\$\\$$1\\$"));
	}

	public void testSplit() {
	compareList("fullSplit", new String[] {"abc", "", "", "de", "f"},
	"abcxxxdexfxx".split("x"));
	compareList("emptyRegexSplit", new String[] {
	"", "a", "b", "c", "x", "x", "d", "e", "x", "f", "x"},
	"abcxxdexfx".split(""));
	compareList("2:", "boo:and:foo".split(":", 2), new String[] {
	"boo", "and:foo"});
	compareList("5:", "boo:and:foo".split(":", 5), new String[] {
	"boo", "and", "foo"});
	compareList("-2:", "boo:and:foo".split(":", -2), new String[] {
	"boo", "and", "foo"});
	compareList("5o", "boo:and:foo".split("o", 5), new String[] {
	"b", "", ":and:f", "", ""});
	compareList("-2o", "boo:and:foo".split("o", -2), new String[] {
	"b", "", ":and:f", "", ""});
	compareList("0o", "boo:and:foo".split("o", 0), new String[] {
	"b", "", ":and:f"});
	compareList("0:", "boo:and:foo".split(":", 0), new String[] {
	"boo", "and", "foo"});
	}

	public void testStartsWith() {
	String haystack = "abcdefghi";
	assertTrue(haystack.startsWith("abc"));
	assertTrue(haystack.startsWith("bc", 1));
	assertTrue(haystack.startsWith(haystack));
	assertFalse(haystack.startsWith(haystack + "j"));
	}

	public void testSubstring() {
	String haystack = "abcdefghi";
	assertEquals("cd", haystack.substring(2, 4));
	assertEquals("bc", "abcdef".substring(1, 3));
	assertEquals("bcdef", "abcdef".substring(1));
	}

	public void testToCharArray() {
	char[] a1 = "abc".toCharArray();
	char[] a2 = new char[] {'a', 'b', 'c'};
	for (int i = 0; i < a1.length; i++) {
	assertEquals(a1[i], a2[i]);
	}
	}

	public void testTrim() {
	trimRightAssertEquals("abc", " \t abc \n ");
	trimRightAssertEquals("abc", "abc".trim());
	trimRightAssertSame("abc", "abc");
	String s = '\u0023' + "hi";
	trimRightAssertSame(s, s);
	trimRightAssertEquals("abc", " abc".trim());
	trimRightAssertEquals("abc", "abc ".trim());
	trimRightAssertEquals("", "".trim());
	trimRightAssertEquals("", " \t ".trim());
	}

	public void testUpperCase() {
	assertEquals("abc", StringCase.toLower("AbC"));
	assertEquals("abc", StringCase.toLower("abc"));
	assertEquals("", StringCase.toLower(""));
	}

	public void testValueOf() {
	assertTrue(String.valueOf(C.FLOAT_VALUE).startsWith(C.FLOAT_STRING));
	assertEquals(C.INT_STRING, String.valueOf(C.INT_VALUE));
	assertEquals(C.LONG_STRING, String.valueOf(C.LONG_VALUE));
	assertTrue(String.valueOf(C.DOUBLE_VALUE).startsWith(C.DOUBLE_STRING));
	assertEquals(C.CHAR_STRING, String.valueOf(C.CHAR_VALUE));
	assertEquals(C.CHAR_ARRAY_STRING, String.valueOf(C.CHAR_ARRAY_VALUE));
	assertEquals(C.CHAR_ARRAY_STRING_SUB, String.valueOf(C.CHAR_ARRAY_VALUE, 1,
	4));
	assertEquals(C.FALSE_STRING, String.valueOf(C.FALSE_VALUE));
	assertEquals(C.TRUE_STRING, String.valueOf(C.TRUE_VALUE));
	}

	/**
	* Helper method for testTrim to avoid compiler optimizations.
	*/
	public void trimRightAssertEquals(String left, String right) {
	assertEquals(left, right.trim());
	}

	/**
	* Helper method for testTrim to avoid compiler optimizations.
	*/
	public void trimRightAssertSame(String left, String right) {
	assertSame(left, right.trim());
	}

	private void compareList(String category, String[] desired, String[] got) {
	assertEquals(category + " length", desired.length, got.length);
	for (int i = 0; i < desired.length; i++) {
	assertEquals(category + " " + i, desired[i], got[i]);
	}
	}

	private String returnNull() {
	return null;
	}

	private String toS(char from) {
	return Character.toString(from);
	}

	}