/*******************************************************************************
 * Copyright (c) 2005, 2009 Oracle. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0, which accompanies this distribution
 * and is available at http://www.eclipse.org/legal/epl-v10.html.
 * 
 * Contributors:
 *     Oracle - initial API and implementation
 ******************************************************************************/
package org.eclipse.jpt.utility.tests.internal;

import java.io.StringWriter;
import java.io.Writer;
import junit.framework.TestCase;
import org.eclipse.jpt.utility.internal.StringTools;

@SuppressWarnings("nls")
public class StringToolsTests extends TestCase {

	public StringToolsTests(String name) {
		super(name);
	}

	private static void assertEquals(String expected, char[] actual) {
		assertEquals(expected, new String(actual));
	}

	// ********** padding/truncating **********

	public void testPad() {
		assertEquals("fred", StringTools.pad("fred", 4));
		assertEquals("fred  ", StringTools.pad("fred", 6));
		boolean exThrown = false;
		try {
			assertEquals("fr", StringTools.pad("fred", 2));
		} catch (IllegalArgumentException ex) {
			exThrown = true;
		}
		assertTrue(exThrown);
	}

	public void testPadCharArray() {
		assertEquals("fred", StringTools.pad(new char[] { 'f', 'r', 'e', 'd' }, 4));
		assertEquals("fred  ", StringTools.pad(new char[] { 'f', 'r', 'e', 'd' }, 6));
		boolean exThrown = false;
		try {
			assertEquals("fr", StringTools.pad(new char[] { 'f', 'r', 'e', 'd' }, 2));
		} catch (IllegalArgumentException ex) {
			exThrown = true;
		}
		assertTrue(exThrown);
	}

	public void testPadOnWriter() {
		Writer writer;
		writer = new StringWriter();
		StringTools.padOn("fred", 4, writer);
		assertEquals("fred", writer.toString());

		writer = new StringWriter();
		StringTools.padOn("fred", 6, writer);
		assertEquals("fred  ", writer.toString());

		writer = new StringWriter();
		boolean exThrown = false;
		try {
			StringTools.padOn("fred", 2, writer);
			fail();
		} catch (IllegalArgumentException ex) {
			exThrown = true;
		}
		assertTrue(exThrown);
	}

	public void testPadOnStringBuffer() {
		StringBuffer sb;
		sb = new StringBuffer();
		StringTools.padOn("fred", 4, sb);
		assertEquals("fred", sb.toString());

		sb = new StringBuffer();
		StringTools.padOn("fred", 6, sb);
		assertEquals("fred  ", sb.toString());

		sb = new StringBuffer();
		boolean exThrown = false;
		try {
			StringTools.padOn("fred", 2, sb);
			fail();
		} catch (IllegalArgumentException ex) {
			exThrown = true;
		}
		assertTrue(exThrown);
	}

	public void testPadOnStringBuilder() {
		StringBuilder sb;
		sb = new StringBuilder();
		StringTools.padOn("fred", 4, sb);
		assertEquals("fred", sb.toString());

		sb = new StringBuilder();
		StringTools.padOn("fred", 6, sb);
		assertEquals("fred  ", sb.toString());

		sb = new StringBuilder();
		boolean exThrown = false;
		try {
			StringTools.padOn("fred", 2, sb);
			fail();
		} catch (IllegalArgumentException ex) {
			exThrown = true;
		}
		assertTrue(exThrown);
	}

	public void testPadOrTruncate() {
		assertEquals("fred", StringTools.padOrTruncate("fred", 4));
		assertEquals("fred  ", StringTools.padOrTruncate("fred", 6));
		assertEquals("fr", StringTools.padOrTruncate("fred", 2));
	}

	public void testPadOrTruncateCharArray() {
		assertEquals("fred", StringTools.padOrTruncate(new char[] { 'f', 'r', 'e', 'd' }, 4));
		assertEquals("fred  ", StringTools.padOrTruncate(new char[] { 'f', 'r', 'e', 'd' }, 6));
		assertEquals("fr", StringTools.padOrTruncate(new char[] { 'f', 'r', 'e', 'd' }, 2));
	}

	public void testPadOrTruncateOnWriter() {
		this.verifyPadOrTruncateOnWriter("fred", "fred", 4);
		this.verifyPadOrTruncateOnWriter("fred  ", "fred", 6);
		this.verifyPadOrTruncateOnWriter("fr", "fred", 2);
	}

	private void verifyPadOrTruncateOnWriter(String expected, String string, int length) {
		Writer writer = new StringWriter();
		StringTools.padOrTruncateOn(string, length, writer);
		assertEquals(expected, writer.toString());
	}

	public void testPadOrTruncateOnStringBuffer() {
		this.verifyPadOrTruncateOnStringBuffer("fred", "fred", 4);
		this.verifyPadOrTruncateOnStringBuffer("fred  ", "fred", 6);
		this.verifyPadOrTruncateOnStringBuffer("fr", "fred", 2);
	}

	private void verifyPadOrTruncateOnStringBuffer(String expected, String string, int length) {
		StringBuffer sb = new StringBuffer();
		StringTools.padOrTruncateOn(string, length, sb);
		assertEquals(expected, sb.toString());
	}

	public void testPadOrTruncateOnStringBuilder() {
		this.verifyPadOrTruncateOnStringBuilder("fred", "fred", 4);
		this.verifyPadOrTruncateOnStringBuilder("fred  ", "fred", 6);
		this.verifyPadOrTruncateOnStringBuilder("fr", "fred", 2);
	}

	private void verifyPadOrTruncateOnStringBuilder(String expected, String string, int length) {
		StringBuilder sb = new StringBuilder();
		StringTools.padOrTruncateOn(string, length, sb);
		assertEquals(expected, sb.toString());
	}

	public void testZeroPad() {
		assertEquals("1234", StringTools.zeroPad("1234", 4));
		assertEquals("001234", StringTools.zeroPad("1234", 6));
		boolean exThrown = false;
		try {
			assertEquals("12", StringTools.zeroPad("1234", 2));
		} catch (IllegalArgumentException ex) {
			exThrown = true;
		}
		assertTrue(exThrown);
	}

	public void testZeroPadCharArray() {
		assertEquals("1234", StringTools.zeroPad(new char[] { '1', '2', '3', '4' }, 4));
		assertEquals("001234", StringTools.zeroPad(new char[] { '1', '2', '3', '4' }, 6));
		boolean exThrown = false;
		try {
			assertEquals("12", StringTools.zeroPad(new char[] { '1', '2', '3', '4' }, 2));
		} catch (IllegalArgumentException ex) {
			exThrown = true;
		}
		assertTrue(exThrown);
	}

	public void testZeroPadOnWriter() {
		Writer writer;
		writer = new StringWriter();
		StringTools.zeroPadOn("1234", 4, writer);
		assertEquals("1234", writer.toString());

		writer = new StringWriter();
		StringTools.zeroPadOn("1234", 6, writer);
		assertEquals("001234", writer.toString());

		writer = new StringWriter();
		boolean exThrown = false;
		try {
			StringTools.zeroPadOn("1234", 2, writer);
			fail();
		} catch (IllegalArgumentException ex) {
			exThrown = true;
		}
		assertTrue(exThrown);
	}

	public void testZeroPadOnStringBuffer() {
		StringBuffer sb;
		sb = new StringBuffer();
		StringTools.zeroPadOn("1234", 4, sb);
		assertEquals("1234", sb.toString());

		sb = new StringBuffer();
		StringTools.zeroPadOn("1234", 6, sb);
		assertEquals("001234", sb.toString());

		sb = new StringBuffer();
		boolean exThrown = false;
		try {
			StringTools.zeroPadOn("1234", 2, sb);
			fail();
		} catch (IllegalArgumentException ex) {
			exThrown = true;
		}
		assertTrue(exThrown);
	}

	public void testZeroPadOnStringBuilder() {
		StringBuilder sb;
		sb = new StringBuilder();
		StringTools.zeroPadOn("1234", 4, sb);
		assertEquals("1234", sb.toString());

		sb = new StringBuilder();
		StringTools.zeroPadOn("1234", 6, sb);
		assertEquals("001234", sb.toString());

		sb = new StringBuilder();
		boolean exThrown = false;
		try {
			StringTools.zeroPadOn("1234", 2, sb);
			fail();
		} catch (IllegalArgumentException ex) {
			exThrown = true;
		}
		assertTrue(exThrown);
	}

	public void testZeroPadOrTruncate() {
		assertEquals("1234", StringTools.zeroPadOrTruncate("1234", 4));
		assertEquals("001234", StringTools.zeroPadOrTruncate("1234", 6));
		assertEquals("34", StringTools.zeroPadOrTruncate("1234", 2));
	}

	public void testZeroPadOrTruncateCharArray() {
		assertEquals("1234", StringTools.zeroPadOrTruncate(new char[] { '1', '2', '3', '4' }, 4));
		assertEquals("001234", StringTools.zeroPadOrTruncate(new char[] { '1', '2', '3', '4' }, 6));
		assertEquals("34", StringTools.zeroPadOrTruncate(new char[] { '1', '2', '3', '4' }, 2));
	}

	public void testZeroPadOrTruncateOnWriter() {
		this.verifyZeroPadOrTruncateOnWriter("1234", "1234", 4);
		this.verifyZeroPadOrTruncateOnWriter("001234", "1234", 6);
		this.verifyZeroPadOrTruncateOnWriter("34", "1234", 2);
	}

	private void verifyZeroPadOrTruncateOnWriter(String expected, String string, int length) {
		Writer writer = new StringWriter();
		StringTools.zeroPadOrTruncateOn(string, length, writer);
		assertEquals(expected, writer.toString());
	}

	public void testZeroPadOrTruncateOnStringBuffer() {
		this.verifyZeroPadOrTruncateOnStringBuffer("1234", "1234", 4);
		this.verifyZeroPadOrTruncateOnStringBuffer("001234", "1234", 6);
		this.verifyZeroPadOrTruncateOnStringBuffer("34", "1234", 2);
	}

	private void verifyZeroPadOrTruncateOnStringBuffer(String expected, String string, int length) {
		StringBuffer sb = new StringBuffer();
		StringTools.zeroPadOrTruncateOn(string, length, sb);
		assertEquals(expected, sb.toString());
	}

	public void testZeroPadOrTruncateOnStringBuilder() {
		this.verifyZeroPadOrTruncateOnStringBuilder("1234", "1234", 4);
		this.verifyZeroPadOrTruncateOnStringBuilder("001234", "1234", 6);
		this.verifyZeroPadOrTruncateOnStringBuilder("34", "1234", 2);
	}

	private void verifyZeroPadOrTruncateOnStringBuilder(String expected, String string, int length) {
		StringBuilder sb = new StringBuilder();
		StringTools.zeroPadOrTruncateOn(string, length, sb);
		assertEquals(expected, sb.toString());
	}

	// ********** delimiting **********

	public void testDelimit() {
		this.verifyDelimit("Employee", "123", "123Employee123");
		this.verifyDelimit("123", "123", "123123123");
		this.verifyDelimit("", "123", "123123");
	}

	private void verifyDelimit(String string, String delimiter, String expectedString) {
		assertEquals(expectedString, StringTools.delimit(string, delimiter));
	}

	public void testDelimitOnWriter() {
		this.verifyDelimitOnWriter("Employee", "123", "123Employee123");
		this.verifyDelimitOnWriter("123", "123", "123123123");
		this.verifyDelimitOnWriter("", "123", "123123");
	}

	private void verifyDelimitOnWriter(String string, String delimiter, String expectedString) {
		Writer writer = new StringWriter();
		StringTools.delimitOn(string, delimiter, writer);
		assertEquals(expectedString, writer.toString());
	}

	public void testDelimitOnStringBuffer() {
		this.verifyDelimitOnStringBuffer("Employee", "123", "123Employee123");
		this.verifyDelimitOnStringBuffer("123", "123", "123123123");
		this.verifyDelimitOnStringBuffer("", "123", "123123");
	}

	private void verifyDelimitOnStringBuffer(String string, String delimiter, String expectedString) {
		StringBuffer sb = new StringBuffer();
		StringTools.delimitOn(string, delimiter, sb);
		assertEquals(expectedString, sb.toString());
	}

	public void testDelimitOnStringBuilder() {
		this.verifyDelimitOnStringBuilder("Employee", "123", "123Employee123");
		this.verifyDelimitOnStringBuilder("123", "123", "123123123");
		this.verifyDelimitOnStringBuilder("", "123", "123123");
	}

	private void verifyDelimitOnStringBuilder(String string, String delimiter, String expectedString) {
		StringBuilder sb = new StringBuilder();
		StringTools.delimitOn(string, delimiter, sb);
		assertEquals(expectedString, sb.toString());
	}

	public void testQuote() {
		this.verifyQuote("Employee", "\"Employee\"");
		this.verifyQuote("123", "\"123\"");
		this.verifyQuote("", "\"\"");
		this.verifyQuote("Emp\"loyee", "\"Emp\"\"loyee\"");
	}

	private void verifyQuote(String string, String expectedString) {
		assertEquals(expectedString, StringTools.quote(string));
	}

	public void testQuoteOnWriter() {
		this.verifyQuoteOnWriter("Employee", "\"Employee\"");
		this.verifyQuoteOnWriter("123", "\"123\"");
		this.verifyQuoteOnWriter("", "\"\"");
		this.verifyQuoteOnWriter("Emp\"loyee", "\"Emp\"\"loyee\"");
	}

	private void verifyQuoteOnWriter(String string, String expectedString) {
		Writer writer = new StringWriter();
		StringTools.quoteOn(string, writer);
		assertEquals(expectedString, writer.toString());
	}

	public void testQuoteOnStringBuffer() {
		this.verifyQuoteOnStringBuffer("Employee", "\"Employee\"");
		this.verifyQuoteOnStringBuffer("123", "\"123\"");
		this.verifyQuoteOnStringBuffer("", "\"\"");
		this.verifyQuoteOnStringBuffer("Emp\"loyee", "\"Emp\"\"loyee\"");
	}

	private void verifyQuoteOnStringBuffer(String string, String expectedString) {
		StringBuffer sb = new StringBuffer();
		StringTools.quoteOn(string, sb);
		assertEquals(expectedString, sb.toString());
	}

	public void testQuoteOnStringBuilder() {
		this.verifyQuoteOnStringBuilder("Employee", "\"Employee\"");
		this.verifyQuoteOnStringBuilder("123", "\"123\"");
		this.verifyQuoteOnStringBuilder("", "\"\"");
		this.verifyQuoteOnStringBuilder("Emp\"loyee", "\"Emp\"\"loyee\"");
	}

	private void verifyQuoteOnStringBuilder(String string, String expectedString) {
		StringBuilder sb = new StringBuilder();
		StringTools.quoteOn(string, sb);
		assertEquals(expectedString, sb.toString());
	}

	// ********** removing characters **********

	public void testRemoveFirstOccurrence() {
		this.verifyRemoveFirstOccurrence("Emplo&yee", '&', "Employee");
		this.verifyRemoveFirstOccurrence("Emplo&yee&", '&', "Employee&");
		this.verifyRemoveFirstOccurrence("Employee &Foo", '&', "Employee Foo");
		this.verifyRemoveFirstOccurrence("Employee&", '&', "Employee");
		this.verifyRemoveFirstOccurrence("&Employee", '&', "Employee");
	}

	private void verifyRemoveFirstOccurrence(String string, char charToRemove, String expectedString) {
		assertEquals(expectedString, StringTools.removeFirstOccurrence(string, charToRemove));
	}

	public void testRemoveFirstOccurrenceCharArray() {
		this.verifyRemoveFirstOccurrenceCharArray("Emplo&yee", '&', "Employee");
		this.verifyRemoveFirstOccurrenceCharArray("Emplo&yee&", '&', "Employee&");
		this.verifyRemoveFirstOccurrenceCharArray("Employee &Foo", '&', "Employee Foo");
		this.verifyRemoveFirstOccurrenceCharArray("Employee&", '&', "Employee");
		this.verifyRemoveFirstOccurrenceCharArray("&Employee", '&', "Employee");
	}

	private void verifyRemoveFirstOccurrenceCharArray(String string, char charToRemove, String expectedString) {
		assertEquals(expectedString, StringTools.removeFirstOccurrence(string.toCharArray(), charToRemove));
	}

	public void testRemoveFirstOccurrenceOnWriter() {
		this.verifyRemoveFirstOccurrenceOnWriter("Emplo&yee", '&', "Employee");
		this.verifyRemoveFirstOccurrenceOnWriter("Emplo&yee&", '&', "Employee&");
		this.verifyRemoveFirstOccurrenceOnWriter("Employee &Foo", '&', "Employee Foo");
		this.verifyRemoveFirstOccurrenceOnWriter("Employee&", '&', "Employee");
		this.verifyRemoveFirstOccurrenceOnWriter("&Employee", '&', "Employee");
	}

	private void verifyRemoveFirstOccurrenceOnWriter(String string, char charToRemove, String expectedString) {
		Writer writer = new StringWriter();
		StringTools.removeFirstOccurrenceOn(string, charToRemove, writer);
		assertEquals(expectedString, writer.toString());
	}

	public void testRemoveFirstOccurrenceOnStringBuffer() {
		this.verifyRemoveFirstOccurrenceOnStringBuffer("Emplo&yee", '&', "Employee");
		this.verifyRemoveFirstOccurrenceOnStringBuffer("Emplo&yee&", '&', "Employee&");
		this.verifyRemoveFirstOccurrenceOnStringBuffer("Employee &Foo", '&', "Employee Foo");
		this.verifyRemoveFirstOccurrenceOnStringBuffer("Employee&", '&', "Employee");
		this.verifyRemoveFirstOccurrenceOnStringBuffer("&Employee", '&', "Employee");
	}

	private void verifyRemoveFirstOccurrenceOnStringBuffer(String string, char charToRemove, String expectedString) {
		StringBuffer sb = new StringBuffer();
		StringTools.removeFirstOccurrenceOn(string, charToRemove, sb);
		assertEquals(expectedString, sb.toString());
	}

	public void testRemoveFirstOccurrenceOnStringBuilder() {
		this.verifyRemoveFirstOccurrenceOnStringBuilder("Emplo&yee", '&', "Employee");
		this.verifyRemoveFirstOccurrenceOnStringBuilder("Emplo&yee&", '&', "Employee&");
		this.verifyRemoveFirstOccurrenceOnStringBuilder("Employee &Foo", '&', "Employee Foo");
		this.verifyRemoveFirstOccurrenceOnStringBuilder("Employee&", '&', "Employee");
		this.verifyRemoveFirstOccurrenceOnStringBuilder("&Employee", '&', "Employee");
	}

	private void verifyRemoveFirstOccurrenceOnStringBuilder(String string, char charToRemove, String expectedString) {
		StringBuilder sb = new StringBuilder();
		StringTools.removeFirstOccurrenceOn(string, charToRemove, sb);
		assertEquals(expectedString, sb.toString());
	}

	public void testRemoveAllOccurrences() {
		this.verifyRemoveAllOccurrences("Employee Fred", ' ', "EmployeeFred");
		this.verifyRemoveAllOccurrences(" Employee ", ' ', "Employee");
		this.verifyRemoveAllOccurrences("Employee   Foo", ' ', "EmployeeFoo");
		this.verifyRemoveAllOccurrences(" Emp loyee   Foo", ' ', "EmployeeFoo");
	}

	private void verifyRemoveAllOccurrences(String string, char charToRemove, String expectedString) {
		assertEquals(expectedString, StringTools.removeAllOccurrences(string, charToRemove));
	}

	public void testRemoveAllOccurrencesCharArray() {
		this.verifyRemoveAllOccurrencesCharArray("Employee Fred", ' ', "EmployeeFred");
		this.verifyRemoveAllOccurrencesCharArray(" Employee ", ' ', "Employee");
		this.verifyRemoveAllOccurrencesCharArray("Employee   Foo", ' ', "EmployeeFoo");
		this.verifyRemoveAllOccurrencesCharArray(" Emp loyee   Foo", ' ', "EmployeeFoo");
	}

	private void verifyRemoveAllOccurrencesCharArray(String string, char charToRemove, String expectedString) {
		assertEquals(expectedString, StringTools.removeAllOccurrences(string.toCharArray(), charToRemove));
	}

	public void testRemoveAllOccurrencesOnWriter() {
		this.verifyRemoveAllOccurrencesOnWriter("Employee Fred", ' ', "EmployeeFred");
		this.verifyRemoveAllOccurrencesOnWriter(" Employee ", ' ', "Employee");
		this.verifyRemoveAllOccurrencesOnWriter("Employee   Foo", ' ', "EmployeeFoo");
		this.verifyRemoveAllOccurrencesOnWriter(" Emp loyee   Foo", ' ', "EmployeeFoo");
	}

	private void verifyRemoveAllOccurrencesOnWriter(String string, char charToRemove, String expectedString) {
		Writer writer = new StringWriter();
		StringTools.removeAllOccurrencesOn(string, charToRemove, writer);
		assertEquals(expectedString, writer.toString());
	}

	public void testRemoveAllOccurrencesOnStringBuffer() {
		this.verifyRemoveAllOccurrencesOnStringBuffer("Employee Fred", ' ', "EmployeeFred");
		this.verifyRemoveAllOccurrencesOnStringBuffer(" Employee ", ' ', "Employee");
		this.verifyRemoveAllOccurrencesOnStringBuffer("Employee   Foo", ' ', "EmployeeFoo");
		this.verifyRemoveAllOccurrencesOnStringBuffer(" Emp loyee   Foo", ' ', "EmployeeFoo");
	}

	private void verifyRemoveAllOccurrencesOnStringBuffer(String string, char charToRemove, String expectedString) {
		StringBuffer sb = new StringBuffer();
		StringTools.removeAllOccurrencesOn(string, charToRemove, sb);
		assertEquals(expectedString, sb.toString());
	}

	public void testRemoveAllOccurrencesOnStringBuilder() {
		this.verifyRemoveAllOccurrencesOnStringBuilder("Employee Fred", ' ', "EmployeeFred");
		this.verifyRemoveAllOccurrencesOnStringBuilder(" Employee ", ' ', "Employee");
		this.verifyRemoveAllOccurrencesOnStringBuilder("Employee   Foo", ' ', "EmployeeFoo");
		this.verifyRemoveAllOccurrencesOnStringBuilder(" Emp loyee   Foo", ' ', "EmployeeFoo");
	}

	private void verifyRemoveAllOccurrencesOnStringBuilder(String string, char charToRemove, String expectedString) {
		StringBuilder sb = new StringBuilder();
		StringTools.removeAllOccurrencesOn(string, charToRemove, sb);
		assertEquals(expectedString, sb.toString());
	}

	public void testRemoveAllWhitespace() {
		this.verifyRemoveAllWhitespace("Employee Fred\t", "EmployeeFred");
		this.verifyRemoveAllWhitespace("\tEmployee\n", "Employee");
		this.verifyRemoveAllWhitespace("Employee \t Foo", "EmployeeFoo");
		this.verifyRemoveAllWhitespace(" Emp\tloyee \n Foo", "EmployeeFoo");
	}

	private void verifyRemoveAllWhitespace(String string, String expectedString) {
		assertEquals(expectedString, StringTools.removeAllWhitespace(string));
	}

	public void testRemoveAllWhitespaceCharArray() {
		this.verifyRemoveAllWhitespaceCharArray("Employee Fred\t", "EmployeeFred");
		this.verifyRemoveAllWhitespaceCharArray("\tEmployee\n", "Employee");
		this.verifyRemoveAllWhitespaceCharArray("Employee \t Foo", "EmployeeFoo");
		this.verifyRemoveAllWhitespaceCharArray(" Emp\tloyee \n Foo", "EmployeeFoo");
	}

	private void verifyRemoveAllWhitespaceCharArray(String string, String expectedString) {
		assertEquals(expectedString, StringTools.removeAllWhitespace(string.toCharArray()));
	}

	public void testRemoveAllWhitespaceOnWriter() {
		this.verifyRemoveAllWhitespaceOnWriter("Employee Fred\t", "EmployeeFred");
		this.verifyRemoveAllWhitespaceOnWriter("\tEmployee\n", "Employee");
		this.verifyRemoveAllWhitespaceOnWriter("Employee \t Foo", "EmployeeFoo");
		this.verifyRemoveAllWhitespaceOnWriter(" Emp\tloyee \n Foo", "EmployeeFoo");
	}

	private void verifyRemoveAllWhitespaceOnWriter(String string, String expectedString) {
		Writer writer = new StringWriter();
		StringTools.removeAllWhitespaceOn(string, writer);
		assertEquals(expectedString, writer.toString());
	}

	public void testRemoveAllWhitespaceOnStringBuffer() {
		this.verifyRemoveAllWhitespaceOnStringBuffer("Employee Fred\t", "EmployeeFred");
		this.verifyRemoveAllWhitespaceOnStringBuffer("\tEmployee\n", "Employee");
		this.verifyRemoveAllWhitespaceOnStringBuffer("Employee \t Foo", "EmployeeFoo");
		this.verifyRemoveAllWhitespaceOnStringBuffer(" Emp\tloyee \n Foo", "EmployeeFoo");
	}

	private void verifyRemoveAllWhitespaceOnStringBuffer(String string, String expectedString) {
		StringBuffer sb = new StringBuffer();
		StringTools.removeAllWhitespaceOn(string, sb);
		assertEquals(expectedString, sb.toString());
	}

	public void testRemoveAllWhitespaceOnStringBuilder() {
		this.verifyRemoveAllWhitespaceOnStringBuilder("Employee Fred\t", "EmployeeFred");
		this.verifyRemoveAllWhitespaceOnStringBuilder("\tEmployee\n", "Employee");
		this.verifyRemoveAllWhitespaceOnStringBuilder("Employee \t Foo", "EmployeeFoo");
		this.verifyRemoveAllWhitespaceOnStringBuilder(" Emp\tloyee \n Foo", "EmployeeFoo");
	}

	private void verifyRemoveAllWhitespaceOnStringBuilder(String string, String expectedString) {
		StringBuilder sb = new StringBuilder();
		StringTools.removeAllWhitespaceOn(string, sb);
		assertEquals(expectedString, sb.toString());
	}
//////////////////////////////
	public void testCompressWhitespace() {
		this.verifyCompressWhitespace("Employee      Fred\t", "Employee Fred ");
		this.verifyCompressWhitespace("\tEmployee  \n", " Employee ");
		this.verifyCompressWhitespace("Employee \t Foo", "Employee Foo");
		this.verifyCompressWhitespace(" Emp\tloyee \n Foo ", " Emp loyee Foo ");
	}

	private void verifyCompressWhitespace(String string, String expectedString) {
		assertEquals(expectedString, StringTools.compressWhitespace(string));
	}

	public void testCompressWhitespaceCharArray() {
		this.verifyCompressWhitespaceCharArray("Employee      Fred\t", "Employee Fred ");
		this.verifyCompressWhitespaceCharArray("\tEmployee  \n", " Employee ");
		this.verifyCompressWhitespaceCharArray("Employee \t Foo", "Employee Foo");
		this.verifyCompressWhitespaceCharArray(" Emp\tloyee \n Foo ", " Emp loyee Foo ");
	}

	private void verifyCompressWhitespaceCharArray(String string, String expectedString) {
		assertEquals(expectedString, StringTools.compressWhitespace(string.toCharArray()));
	}

	public void testCompressWhitespaceOnWriter() {
		this.verifyCompressWhitespaceOnWriter("Employee      Fred\t", "Employee Fred ");
		this.verifyCompressWhitespaceOnWriter("\tEmployee  \n", " Employee ");
		this.verifyCompressWhitespaceOnWriter("Employee \t Foo", "Employee Foo");
		this.verifyCompressWhitespaceOnWriter(" Emp\tloyee \n Foo ", " Emp loyee Foo ");
	}

	private void verifyCompressWhitespaceOnWriter(String string, String expectedString) {
		Writer writer = new StringWriter();
		StringTools.compressWhitespaceOn(string, writer);
		assertEquals(expectedString, writer.toString());
	}

	public void testCompressWhitespaceOnStringBuffer() {
		this.verifyCompressWhitespaceOnStringBuffer("Employee      Fred\t", "Employee Fred ");
		this.verifyCompressWhitespaceOnStringBuffer("\tEmployee  \n", " Employee ");
		this.verifyCompressWhitespaceOnStringBuffer("Employee \t Foo", "Employee Foo");
		this.verifyCompressWhitespaceOnStringBuffer(" Emp\tloyee \n Foo ", " Emp loyee Foo ");
	}

	private void verifyCompressWhitespaceOnStringBuffer(String string, String expectedString) {
		StringBuffer sb = new StringBuffer();
		StringTools.compressWhitespaceOn(string, sb);
		assertEquals(expectedString, sb.toString());
	}

	public void testCompressWhitespaceOnStringBuilder() {
		this.verifyCompressWhitespaceOnStringBuilder("Employee      Fred\t", "Employee Fred ");
		this.verifyCompressWhitespaceOnStringBuilder("\tEmployee  \n", " Employee ");
		this.verifyCompressWhitespaceOnStringBuilder("Employee \t Foo", "Employee Foo");
		this.verifyCompressWhitespaceOnStringBuilder(" Emp\tloyee \n Foo ", " Emp loyee Foo ");
	}

	private void verifyCompressWhitespaceOnStringBuilder(String string, String expectedString) {
		StringBuilder sb = new StringBuilder();
		StringTools.compressWhitespaceOn(string, sb);
		assertEquals(expectedString, sb.toString());
	}

	// ********** common prefix **********

	public void testCommonPrefixLength() {
		assertEquals(3, StringTools.commonPrefixLength("fooZZZ", "fooBBB"));
		assertEquals(3, StringTools.commonPrefixLength("foo", "fooBBB"));
		assertEquals(3, StringTools.commonPrefixLength("fooZZZ", "foo"));
		assertEquals(3, StringTools.commonPrefixLength("foo", "foo"));
	}

	public void testCommonPrefixLengthMax() {
		assertEquals(2, StringTools.commonPrefixLength("fooZZZ", "fooBBB", 2));
		assertEquals(2, StringTools.commonPrefixLength("foo", "fooBBB", 2));
		assertEquals(2, StringTools.commonPrefixLength("fooZZZ", "foo", 2));
		assertEquals(2, StringTools.commonPrefixLength("foo", "foo", 2));
	}

	// ********** capitalization **********

	public void testCapitalizeCharArray() {
		this.verifyCapitalizeCharArray("Oracle", new char[] { 'O', 'r', 'a', 'c', 'l', 'e' });
		this.verifyCapitalizeCharArray("Oracle", new char[] { 'o', 'r', 'a', 'c', 'l', 'e' });
		this.verifyCapitalizeCharArray("   ", new char[] { ' ', ' ', ' ' });
		this.verifyCapitalizeCharArray("ORACLE", new char[] { 'O', 'R', 'A', 'C', 'L', 'E' });
		this.verifyCapitalizeCharArray("", new char[0]);
		this.verifyCapitalizeCharArray("A", new char[] { 'a' });
		this.verifyCapitalizeCharArray("\u00C9cole", new char[] { '\u00E9', 'c', 'o', 'l', 'e' });
	}

	private void verifyCapitalizeCharArray(String expected, char[] string) {
		assertEquals(expected, StringTools.capitalize(string));
	}

	public void testCapitalizeString() {
		this.verifyCapitalizeString("Oracle", "Oracle");
		this.verifyCapitalizeString("Oracle", "oracle");
		this.verifyCapitalizeString("   ", "   ");
		this.verifyCapitalizeString("ORACLE", "ORACLE");
		this.verifyCapitalizeString("", "");
		this.verifyCapitalizeString("A", "a");
		this.verifyCapitalizeString("\u00C9cole", "\u00E9cole"); // �cole->�COLE
	}

	private void verifyCapitalizeString(String expected, String string) {
		assertEquals(expected, StringTools.capitalize(string));
	}

	public void testCapitalizeOnCharArrayStringBuffer() {
		this.verifyCapitalizeOnCharArrayStringBuffer("Oracle", new char[] { 'O', 'r', 'a', 'c', 'l', 'e' });
		this.verifyCapitalizeOnCharArrayStringBuffer("Oracle", new char[] { 'o', 'r', 'a', 'c', 'l', 'e' });
		this.verifyCapitalizeOnCharArrayStringBuffer("   ", new char[] { ' ', ' ', ' ' });
		this.verifyCapitalizeOnCharArrayStringBuffer("ORACLE", new char[] { 'O', 'R', 'A', 'C', 'L', 'E' });
		this.verifyCapitalizeOnCharArrayStringBuffer("", new char[0]);
		this.verifyCapitalizeOnCharArrayStringBuffer("A", new char[] { 'a' });
		this.verifyCapitalizeOnCharArrayStringBuffer("\u00C9cole", new char[] { '\u00E9', 'c', 'o', 'l', 'e' });
	}

	private void verifyCapitalizeOnCharArrayStringBuffer(String expected, char[] string) {
		StringBuffer sb = new StringBuffer();
		StringTools.capitalizeOn(string, sb);
		assertEquals(expected, sb.toString());
	}

	public void testCapitalizeOnCharArrayStringBuilder() {
		this.verifyCapitalizeOnCharArrayStringBuilder("Oracle", new char[] { 'O', 'r', 'a', 'c', 'l', 'e' });
		this.verifyCapitalizeOnCharArrayStringBuilder("Oracle", new char[] { 'o', 'r', 'a', 'c', 'l', 'e' });
		this.verifyCapitalizeOnCharArrayStringBuilder("   ", new char[] { ' ', ' ', ' ' });
		this.verifyCapitalizeOnCharArrayStringBuilder("ORACLE", new char[] { 'O', 'R', 'A', 'C', 'L', 'E' });
		this.verifyCapitalizeOnCharArrayStringBuilder("", new char[0]);
		this.verifyCapitalizeOnCharArrayStringBuilder("A", new char[] { 'a' });
		this.verifyCapitalizeOnCharArrayStringBuilder("\u00C9cole", new char[] { '\u00E9', 'c', 'o', 'l', 'e' });
	}

	private void verifyCapitalizeOnCharArrayStringBuilder(String expected, char[] string) {
		StringBuilder sb = new StringBuilder();
		StringTools.capitalizeOn(string, sb);
		assertEquals(expected, sb.toString());
	}

	public void testCapitalizeOnStringStringBuffer() {
		this.verifyCapitalizeOnStringStringBuffer("Oracle", "Oracle");
		this.verifyCapitalizeOnStringStringBuffer("Oracle", "oracle");
		this.verifyCapitalizeOnStringStringBuffer("   ", "   ");
		this.verifyCapitalizeOnStringStringBuffer("ORACLE", "ORACLE");
		this.verifyCapitalizeOnStringStringBuffer("", "");
		this.verifyCapitalizeOnStringStringBuffer("A", "a");
		this.verifyCapitalizeOnStringStringBuffer("\u00C9cole", "\u00E9cole"); // �cole->�COLE
	}

	private void verifyCapitalizeOnStringStringBuffer(String expected, String string) {
		StringBuffer sb = new StringBuffer();
		StringTools.capitalizeOn(string, sb);
		assertEquals(expected, sb.toString());
	}

	public void testCapitalizeOnStringStringBuilder() {
		this.verifyCapitalizeOnStringStringBuilder("Oracle", "Oracle");
		this.verifyCapitalizeOnStringStringBuilder("Oracle", "oracle");
		this.verifyCapitalizeOnStringStringBuilder("   ", "   ");
		this.verifyCapitalizeOnStringStringBuilder("ORACLE", "ORACLE");
		this.verifyCapitalizeOnStringStringBuilder("", "");
		this.verifyCapitalizeOnStringStringBuilder("A", "a");
		this.verifyCapitalizeOnStringStringBuilder("\u00C9cole", "\u00E9cole"); // �cole->�COLE
	}

	private void verifyCapitalizeOnStringStringBuilder(String expected, String string) {
		StringBuilder sb = new StringBuilder();
		StringTools.capitalizeOn(string, sb);
		assertEquals(expected, sb.toString());
	}

	public void testCapitalizeOnCharArrayWriter() {
		this.verifyCapitalizeOnCharArrayWriter("Oracle", new char[] { 'O', 'r', 'a', 'c', 'l', 'e' });
		this.verifyCapitalizeOnCharArrayWriter("Oracle", new char[] { 'o', 'r', 'a', 'c', 'l', 'e' });
		this.verifyCapitalizeOnCharArrayWriter("   ", new char[] { ' ', ' ', ' ' });
		this.verifyCapitalizeOnCharArrayWriter("ORACLE", new char[] { 'O', 'R', 'A', 'C', 'L', 'E' });
		this.verifyCapitalizeOnCharArrayWriter("", new char[0]);
		this.verifyCapitalizeOnCharArrayWriter("A", new char[] { 'a' });
		this.verifyCapitalizeOnCharArrayWriter("\u00C9cole", new char[] { '\u00E9', 'c', 'o', 'l', 'e' });
	}

	private void verifyCapitalizeOnCharArrayWriter(String expected, char[] string) {
		Writer writer = new StringWriter();
		StringTools.capitalizeOn(string, writer);
		assertEquals(expected, writer.toString());
	}

	public void testCapitalizeOnStringWriter() {
		this.verifyCapitalizeOnStringWriter("Oracle", "Oracle");
		this.verifyCapitalizeOnStringWriter("Oracle", "oracle");
		this.verifyCapitalizeOnStringWriter("   ", "   ");
		this.verifyCapitalizeOnStringWriter("ORACLE", "ORACLE");
		this.verifyCapitalizeOnStringWriter("", "");
		this.verifyCapitalizeOnStringWriter("A", "a");
		this.verifyCapitalizeOnStringWriter("\u00C9cole", "\u00E9cole"); // �cole->�COLE
	}

	private void verifyCapitalizeOnStringWriter(String expected, String string) {
		Writer writer = new StringWriter();
		StringTools.capitalizeOn(string, writer);
		assertEquals(expected, writer.toString());
	}

	public void testUnapitalizeCharArray() {
		this.verifyUncapitalizeCharArray("oracle", new char[] { 'O', 'r', 'a', 'c', 'l', 'e' });
		this.verifyUncapitalizeCharArray("oracle", new char[] { 'o', 'r', 'a', 'c', 'l', 'e' });
		this.verifyUncapitalizeCharArray("   ", new char[] { ' ', ' ', ' ' });
		this.verifyUncapitalizeCharArray("ORACLE", new char[] { 'O', 'R', 'A', 'C', 'L', 'E' });
		this.verifyUncapitalizeCharArray("", new char[0]);
		this.verifyUncapitalizeCharArray("a", new char[] { 'A' });
		this.verifyUncapitalizeCharArray("\u00E9cole", new char[] { '\u00C9', 'c', 'o', 'l', 'e' });
	}

	private void verifyUncapitalizeCharArray(String expected, char[] string) {
		assertEquals(expected, StringTools.uncapitalize(string));
	}

	public void testUncapitalizeString() {
		this.verifyUncapitalizeString("oracle", "Oracle");
		this.verifyUncapitalizeString("oracle", "oracle");
		this.verifyUncapitalizeString("   ", "   ");
		this.verifyUncapitalizeString("ORACLE", "ORACLE");
		this.verifyUncapitalizeString("", "");
		this.verifyUncapitalizeString("a", "A");
		this.verifyUncapitalizeString("\u00E9cole", "\u00C9cole"); // �cole->�COLE
	}

	private void verifyUncapitalizeString(String expected, String string) {
		assertEquals(expected, StringTools.uncapitalize(string));
	}

	public void testUncapitalizeOnCharArrayStringBuffer() {
		this.verifyUncapitalizeOnCharArrayStringBuffer("oracle", new char[] { 'O', 'r', 'a', 'c', 'l', 'e' });
		this.verifyUncapitalizeOnCharArrayStringBuffer("oracle", new char[] { 'o', 'r', 'a', 'c', 'l', 'e' });
		this.verifyUncapitalizeOnCharArrayStringBuffer("   ", new char[] { ' ', ' ', ' ' });
		this.verifyUncapitalizeOnCharArrayStringBuffer("ORACLE", new char[] { 'O', 'R', 'A', 'C', 'L', 'E' });
		this.verifyUncapitalizeOnCharArrayStringBuffer("", new char[0]);
		this.verifyUncapitalizeOnCharArrayStringBuffer("a", new char[] { 'A' });
		this.verifyUncapitalizeOnCharArrayStringBuffer("\u00E9cole", new char[] { '\u00C9', 'c', 'o', 'l', 'e' });
	}

	private void verifyUncapitalizeOnCharArrayStringBuffer(String expected, char[] string) {
		StringBuffer sb = new StringBuffer();
		StringTools.uncapitalizeOn(string, sb);
		assertEquals(expected, sb.toString());
	}

	public void testUncapitalizeOnCharArrayStringBuilder() {
		this.verifyUncapitalizeOnCharArrayStringBuilder("oracle", new char[] { 'O', 'r', 'a', 'c', 'l', 'e' });
		this.verifyUncapitalizeOnCharArrayStringBuilder("oracle", new char[] { 'o', 'r', 'a', 'c', 'l', 'e' });
		this.verifyUncapitalizeOnCharArrayStringBuilder("   ", new char[] { ' ', ' ', ' ' });
		this.verifyUncapitalizeOnCharArrayStringBuilder("ORACLE", new char[] { 'O', 'R', 'A', 'C', 'L', 'E' });
		this.verifyUncapitalizeOnCharArrayStringBuilder("", new char[0]);
		this.verifyUncapitalizeOnCharArrayStringBuilder("a", new char[] { 'A' });
		this.verifyUncapitalizeOnCharArrayStringBuilder("\u00E9cole", new char[] { '\u00C9', 'c', 'o', 'l', 'e' });
	}

	private void verifyUncapitalizeOnCharArrayStringBuilder(String expected, char[] string) {
		StringBuilder sb = new StringBuilder();
		StringTools.uncapitalizeOn(string, sb);
		assertEquals(expected, sb.toString());
	}

	public void testUncapitalizeOnStringStringBuffer() {
		this.verifyUncapitalizeOnStringStringBuffer("oracle", "Oracle");
		this.verifyUncapitalizeOnStringStringBuffer("oracle", "oracle");
		this.verifyUncapitalizeOnStringStringBuffer("   ", "   ");
		this.verifyUncapitalizeOnStringStringBuffer("ORACLE", "ORACLE");
		this.verifyUncapitalizeOnStringStringBuffer("", "");
		this.verifyUncapitalizeOnStringStringBuffer("a", "A");
		this.verifyUncapitalizeOnStringStringBuffer("\u00E9cole", "\u00C9cole"); // �cole->�COLE
	}

	private void verifyUncapitalizeOnStringStringBuffer(String expected, String string) {
		StringBuffer sb = new StringBuffer();
		StringTools.uncapitalizeOn(string, sb);
		assertEquals(expected, sb.toString());
	}

	public void testUncapitalizeOnStringStringBuilder() {
		this.verifyUncapitalizeOnStringStringBuilder("oracle", "Oracle");
		this.verifyUncapitalizeOnStringStringBuilder("oracle", "oracle");
		this.verifyUncapitalizeOnStringStringBuilder("   ", "   ");
		this.verifyUncapitalizeOnStringStringBuilder("ORACLE", "ORACLE");
		this.verifyUncapitalizeOnStringStringBuilder("", "");
		this.verifyUncapitalizeOnStringStringBuilder("a", "A");
		this.verifyUncapitalizeOnStringStringBuilder("\u00E9cole", "\u00C9cole"); // �cole->�COLE
	}

	private void verifyUncapitalizeOnStringStringBuilder(String expected, String string) {
		StringBuilder sb = new StringBuilder();
		StringTools.uncapitalizeOn(string, sb);
		assertEquals(expected, sb.toString());
	}

	public void testUncapitalizeOnCharArrayWriter() {
		this.verifyUncapitalizeOnCharArrayWriter("oracle", new char[] { 'O', 'r', 'a', 'c', 'l', 'e' });
		this.verifyUncapitalizeOnCharArrayWriter("oracle", new char[] { 'o', 'r', 'a', 'c', 'l', 'e' });
		this.verifyUncapitalizeOnCharArrayWriter("   ", new char[] { ' ', ' ', ' ' });
		this.verifyUncapitalizeOnCharArrayWriter("ORACLE", new char[] { 'O', 'R', 'A', 'C', 'L', 'E' });
		this.verifyUncapitalizeOnCharArrayWriter("", new char[0]);
		this.verifyUncapitalizeOnCharArrayWriter("a", new char[] { 'A' });
		this.verifyUncapitalizeOnCharArrayWriter("\u00E9cole", new char[] { '\u00C9', 'c', 'o', 'l', 'e' });
	}

	private void verifyUncapitalizeOnCharArrayWriter(String expected, char[] string) {
		Writer writer = new StringWriter();
		StringTools.uncapitalizeOn(string, writer);
		assertEquals(expected, writer.toString());
	}

	public void testUncapitalizeOnStringWriter() {
		this.verifyUncapitalizeOnStringWriter("oracle", "Oracle");
		this.verifyUncapitalizeOnStringWriter("oracle", "oracle");
		this.verifyUncapitalizeOnStringWriter("   ", "   ");
		this.verifyUncapitalizeOnStringWriter("ORACLE", "ORACLE");
		this.verifyUncapitalizeOnStringWriter("", "");
		this.verifyUncapitalizeOnStringWriter("a", "A");
		this.verifyUncapitalizeOnStringWriter("\u00E9cole", "\u00C9cole"); // �cole->�COLE
	}

	private void verifyUncapitalizeOnStringWriter(String expected, String string) {
		Writer writer = new StringWriter();
		StringTools.uncapitalizeOn(string, writer);
		assertEquals(expected, writer.toString());
	}

	// ********** queries **********

	public void testStringIsEmptyString() {
		assertTrue(StringTools.stringIsEmpty((String) null));
		assertTrue(StringTools.stringIsEmpty(""));
		assertTrue(StringTools.stringIsEmpty("      "));
		assertTrue(StringTools.stringIsEmpty("      \t\t   "));
		assertTrue(StringTools.stringIsEmpty("      \t\t   " + StringTools.CR));
	}

	public void testStringIsEmptyCharArray() {
		assertTrue(StringTools.stringIsEmpty((char[]) null));
		this.verifyStringIsEmptyCharArray("");
		this.verifyStringIsEmptyCharArray("      \t\t   ");
		this.verifyStringIsEmptyCharArray("      ");
		this.verifyStringIsEmptyCharArray("      \t\t   " + StringTools.CR);
	}

	private void verifyStringIsEmptyCharArray(String string) {
		assertTrue(StringTools.stringIsEmpty(string.toCharArray()));
	}
	
	public void testStringsAreEqualStringString() {
		assertTrue(StringTools.stringsAreEqual((String) null, (String) null));
		assertFalse(StringTools.stringsAreEqual(null, "asdf"));
		assertFalse(StringTools.stringsAreEqual("asdf", null));
		assertTrue(StringTools.stringsAreEqual("asdf", "asdf"));
		assertFalse(StringTools.stringsAreEqual("asdf", "ASDF"));
	}
	
	public void testStringsAreEqualCharArrayCharArray() {
		assertTrue(StringTools.stringsAreEqual((char[]) null, (char[]) null));
		assertFalse(StringTools.stringsAreEqual((char[]) null, "asdf".toCharArray()));
		assertFalse(StringTools.stringsAreEqual("asdf".toCharArray(), (char[]) null));
		assertTrue(StringTools.stringsAreEqual("asdf".toCharArray(), "asdf".toCharArray()));
		assertFalse(StringTools.stringsAreEqual("asdf".toCharArray(), "ASDF".toCharArray()));
	}
	
	public void testStringsAreEqualIgnoreCaseStringString() {
		assertTrue(StringTools.stringsAreEqualIgnoreCase((String) null, (String) null));
		assertFalse(StringTools.stringsAreEqualIgnoreCase(null, "asdf"));
		assertFalse(StringTools.stringsAreEqualIgnoreCase("asdf", null));
		assertTrue(StringTools.stringsAreEqualIgnoreCase("asdf", "asdf"));
		assertTrue(StringTools.stringsAreEqualIgnoreCase("asdf", "ASDF"));
	}

	public void testStringsAreEqualIgnoreCaseCharArrayCharArray() {
		assertTrue(StringTools.stringsAreEqualIgnoreCase((char[]) null, (char[]) null));
		assertFalse(StringTools.stringsAreEqualIgnoreCase((char[]) null, "asdf".toCharArray()));
		assertFalse(StringTools.stringsAreEqualIgnoreCase("asdf".toCharArray(), (char[]) null));
		assertTrue(StringTools.stringsAreEqualIgnoreCase("asdf".toCharArray(), "asdf".toCharArray()));
		assertTrue(StringTools.stringsAreEqualIgnoreCase("asdf".toCharArray(), "ASDF".toCharArray()));
	}

	public void testStringStartsWithIgnoreCaseStringString() {
		assertTrue(StringTools.stringStartsWithIgnoreCase("asdf", "as"));
		assertTrue(StringTools.stringStartsWithIgnoreCase("asdf", "aS"));
		assertTrue(StringTools.stringStartsWithIgnoreCase("asdf", ""));
		assertTrue(StringTools.stringStartsWithIgnoreCase("asdf", "A"));

		assertFalse(StringTools.stringStartsWithIgnoreCase("asdf", "bsdf"));
		assertFalse(StringTools.stringStartsWithIgnoreCase("asdf", "g"));
		assertFalse(StringTools.stringStartsWithIgnoreCase("asdf", "asdg"));
		assertFalse(StringTools.stringStartsWithIgnoreCase("asdf", "asdfg"));
		assertFalse(StringTools.stringStartsWithIgnoreCase("asdf", "asdfgggggg"));
	}

	public void testStringStartsWithIgnoreCaseCharArrayCharArray() {
		assertTrue(StringTools.stringStartsWithIgnoreCase("asdf".toCharArray(), "as".toCharArray()));
		assertTrue(StringTools.stringStartsWithIgnoreCase("asdf".toCharArray(), "aS".toCharArray()));
		assertTrue(StringTools.stringStartsWithIgnoreCase("asdf".toCharArray(), "".toCharArray()));
		assertTrue(StringTools.stringStartsWithIgnoreCase("asdf".toCharArray(), "A".toCharArray()));
		assertTrue(StringTools.stringStartsWithIgnoreCase("asdf".toCharArray(), "ASDF".toCharArray()));
		assertTrue(StringTools.stringStartsWithIgnoreCase("asdf".toCharArray(), "asdf".toCharArray()));

		assertFalse(StringTools.stringStartsWithIgnoreCase("asdf".toCharArray(), "bsdf".toCharArray()));
		assertFalse(StringTools.stringStartsWithIgnoreCase("asdf".toCharArray(), "g".toCharArray()));
		assertFalse(StringTools.stringStartsWithIgnoreCase("asdf".toCharArray(), "asdg".toCharArray()));
		assertFalse(StringTools.stringStartsWithIgnoreCase("asdf".toCharArray(), "asdfg".toCharArray()));
		assertFalse(StringTools.stringStartsWithIgnoreCase("asdf".toCharArray(), "asdfgggggg".toCharArray()));
	}

	public void testCharactersAreEqualIgnoreCase() {
		assertTrue(StringTools.charactersAreEqualIgnoreCase('a', 'a'));
		assertTrue(StringTools.charactersAreEqualIgnoreCase('a', 'A'));
		assertTrue(StringTools.charactersAreEqualIgnoreCase('A', 'a'));
		assertTrue(StringTools.charactersAreEqualIgnoreCase('A', 'A'));
		
		assertFalse(StringTools.charactersAreEqualIgnoreCase('a', 'b'));
		assertFalse(StringTools.charactersAreEqualIgnoreCase('A', 'b'));
	}

	public void testStringIsUppercase() {
		this.verifyStringIsUppercase("FOO");
		this.verifyStringIsUppercase("FOO2");
		this.verifyStringIsUppercase("F O O");
		this.denyStringIsUppercase("Foo");
		this.denyStringIsUppercase("");
	}

	private void verifyStringIsUppercase(String s) {
		assertTrue(StringTools.stringIsUppercase(s));
		assertTrue(StringTools.stringIsUppercase(s.toCharArray()));
	}

	private void denyStringIsUppercase(String s) {
		assertFalse(StringTools.stringIsUppercase(s));
		assertFalse(StringTools.stringIsUppercase(s.toCharArray()));
	}

	public void testStringIsLowercase() {
		this.verifyStringIsLowercase("foo");
		this.verifyStringIsLowercase("foo2");
		this.verifyStringIsLowercase("f o o");
		this.denyStringIsLowercase("Foo");
		this.denyStringIsLowercase("");
	}

	private void verifyStringIsLowercase(String s) {
		assertTrue(StringTools.stringIsLowercase(s));
		assertTrue(StringTools.stringIsLowercase(s.toCharArray()));
	}

	private void denyStringIsLowercase(String s) {
		assertFalse(StringTools.stringIsLowercase(s));
		assertFalse(StringTools.stringIsLowercase(s.toCharArray()));
	}

	// ********** convert camel-case to all-caps **********

	public void testConvertCamelCaseToAllCaps() {
		assertEquals("TEST", StringTools.convertCamelCaseToAllCaps("test"));
		assertEquals("TEST", StringTools.convertCamelCaseToAllCaps("TEST"));
		assertEquals("TEST_TEST", StringTools.convertCamelCaseToAllCaps("testTest"));
		assertEquals("TEST_TEST", StringTools.convertCamelCaseToAllCaps("TestTest"));
		assertEquals("TEST_TEST_TEST", StringTools.convertCamelCaseToAllCaps("testTESTTest"));
		assertEquals("TEST_TEST_TEST", StringTools.convertCamelCaseToAllCaps("TestTESTTest"));
		assertEquals("TEST_TEST_TEST_T", StringTools.convertCamelCaseToAllCaps("TestTESTTestT"));
	}

	public void testConvertCamelCaseToAllCapsOnWriter() {
		this.verifyConvertCamelCaseToAllCapsOnWriter("TEST", "test");
		this.verifyConvertCamelCaseToAllCapsOnWriter("TEST", "TEST");
		this.verifyConvertCamelCaseToAllCapsOnWriter("TEST_TEST", "testTest");
		this.verifyConvertCamelCaseToAllCapsOnWriter("TEST_TEST", "TestTest");
		this.verifyConvertCamelCaseToAllCapsOnWriter("TEST_TEST_TEST", "testTESTTest");
		this.verifyConvertCamelCaseToAllCapsOnWriter("TEST_TEST_TEST", "TestTESTTest");
		this.verifyConvertCamelCaseToAllCapsOnWriter("TEST_TEST_TEST_T", "TestTESTTestT");
	}

	private void verifyConvertCamelCaseToAllCapsOnWriter(String expected, String string) {
		Writer writer = new StringWriter();
		StringTools.convertCamelCaseToAllCapsOn(string, writer);
		assertEquals(expected, writer.toString());
	}

	public void testConvertCamelCaseToAllCapsOnStringBuffer() {
		this.verifyConvertCamelCaseToAllCapsOnStringBuffer("TEST", "test");
		this.verifyConvertCamelCaseToAllCapsOnStringBuffer("TEST", "TEST");
		this.verifyConvertCamelCaseToAllCapsOnStringBuffer("TEST_TEST", "testTest");
		this.verifyConvertCamelCaseToAllCapsOnStringBuffer("TEST_TEST", "TestTest");
		this.verifyConvertCamelCaseToAllCapsOnStringBuffer("TEST_TEST_TEST", "testTESTTest");
		this.verifyConvertCamelCaseToAllCapsOnStringBuffer("TEST_TEST_TEST", "TestTESTTest");
		this.verifyConvertCamelCaseToAllCapsOnStringBuffer("TEST_TEST_TEST_T", "TestTESTTestT");
	}

	private void verifyConvertCamelCaseToAllCapsOnStringBuffer(String expected, String string) {
		StringBuffer sb = new StringBuffer();
		StringTools.convertCamelCaseToAllCapsOn(string, sb);
		assertEquals(expected, sb.toString());
	}

	public void testConvertCamelCaseToAllCapsOnStringBuilder() {
		this.verifyConvertCamelCaseToAllCapsOnStringBuilder("TEST", "test");
		this.verifyConvertCamelCaseToAllCapsOnStringBuilder("TEST", "TEST");
		this.verifyConvertCamelCaseToAllCapsOnStringBuilder("TEST_TEST", "testTest");
		this.verifyConvertCamelCaseToAllCapsOnStringBuilder("TEST_TEST", "TestTest");
		this.verifyConvertCamelCaseToAllCapsOnStringBuilder("TEST_TEST_TEST", "testTESTTest");
		this.verifyConvertCamelCaseToAllCapsOnStringBuilder("TEST_TEST_TEST", "TestTESTTest");
		this.verifyConvertCamelCaseToAllCapsOnStringBuilder("TEST_TEST_TEST_T", "TestTESTTestT");
	}

	private void verifyConvertCamelCaseToAllCapsOnStringBuilder(String expected, String string) {
		StringBuilder sb = new StringBuilder();
		StringTools.convertCamelCaseToAllCapsOn(string, sb);
		assertEquals(expected, sb.toString());
	}

	public void testConvertCamelCaseToAllCapsMaxLength() {
		assertEquals("TEST", StringTools.convertCamelCaseToAllCaps("test", 44));
		assertEquals("TEST", StringTools.convertCamelCaseToAllCaps("test", 4));
		assertEquals("TES", StringTools.convertCamelCaseToAllCaps("test", 3));
		assertEquals("TEST", StringTools.convertCamelCaseToAllCaps("TEST", 5));
		assertEquals("TE", StringTools.convertCamelCaseToAllCaps("TEST", 2));
		assertEquals("TEST_TEST", StringTools.convertCamelCaseToAllCaps("testTest", 9));
		assertEquals("TEST_TES", StringTools.convertCamelCaseToAllCaps("testTest", 8));
		assertEquals("TEST_T", StringTools.convertCamelCaseToAllCaps("testTest", 6));
		assertEquals("TEST_", StringTools.convertCamelCaseToAllCaps("testTest", 5));
		assertEquals("TEST", StringTools.convertCamelCaseToAllCaps("testTest", 4));
		assertEquals("TEST_TEST", StringTools.convertCamelCaseToAllCaps("TestTest", 9));
		assertEquals("TEST_TEST", StringTools.convertCamelCaseToAllCaps("TestTest", 1100));
		assertEquals("TEST_TEST_", StringTools.convertCamelCaseToAllCaps("testTESTTest", 10));
		assertEquals("TEST_TEST_TEST", StringTools.convertCamelCaseToAllCaps("TestTESTTest", 14));
		assertEquals("TEST_TEST_TEST_T", StringTools.convertCamelCaseToAllCaps("TestTESTTestT", 16));
		assertEquals("TEST_TEST_TEST_", StringTools.convertCamelCaseToAllCaps("TestTESTTestT", 15));
	}

	public void testConvertCamelCaseToAllCapsMaxLengthOnWriter() {
		this.verifyConvertCamelCaseToAllCapsMaxLengthOnWriter("TEST", "test", 44);
		this.verifyConvertCamelCaseToAllCapsMaxLengthOnWriter("TEST", "test", 4);
		this.verifyConvertCamelCaseToAllCapsMaxLengthOnWriter("TES", "test", 3);
		this.verifyConvertCamelCaseToAllCapsMaxLengthOnWriter("TEST", "TEST", 5);
		this.verifyConvertCamelCaseToAllCapsMaxLengthOnWriter("TE", "TEST", 2);
		this.verifyConvertCamelCaseToAllCapsMaxLengthOnWriter("TEST_TEST", "testTest", 9);
		this.verifyConvertCamelCaseToAllCapsMaxLengthOnWriter("TEST_TES", "testTest", 8);
		this.verifyConvertCamelCaseToAllCapsMaxLengthOnWriter("TEST_T", "testTest", 6);
		this.verifyConvertCamelCaseToAllCapsMaxLengthOnWriter("TEST_", "testTest", 5);
		this.verifyConvertCamelCaseToAllCapsMaxLengthOnWriter("TEST", "testTest", 4);
		this.verifyConvertCamelCaseToAllCapsMaxLengthOnWriter("TEST_TEST", "TestTest", 9);
		this.verifyConvertCamelCaseToAllCapsMaxLengthOnWriter("TEST_TEST", "TestTest", 1100);
		this.verifyConvertCamelCaseToAllCapsMaxLengthOnWriter("TEST_TEST_", "testTESTTest", 10);
		this.verifyConvertCamelCaseToAllCapsMaxLengthOnWriter("TEST_TEST_TEST", "TestTESTTest", 14);
		this.verifyConvertCamelCaseToAllCapsMaxLengthOnWriter("TEST_TEST_TEST_T", "TestTESTTestT", 16);
		this.verifyConvertCamelCaseToAllCapsMaxLengthOnWriter("TEST_TEST_TEST_", "TestTESTTestT", 15);
	}

	private void verifyConvertCamelCaseToAllCapsMaxLengthOnWriter(String expected, String string, int max) {
		Writer writer = new StringWriter();
		StringTools.convertCamelCaseToAllCapsOn(string, max, writer);
		assertEquals(expected, writer.toString());
	}

	public void testConvertCamelCaseToAllCapsMaxLengthOnStringBuffer() {
		this.verifyConvertCamelCaseToAllCapsMaxLengthOnStringBuffer("TEST", "test", 44);
		this.verifyConvertCamelCaseToAllCapsMaxLengthOnStringBuffer("TEST", "test", 4);
		this.verifyConvertCamelCaseToAllCapsMaxLengthOnStringBuffer("TES", "test", 3);
		this.verifyConvertCamelCaseToAllCapsMaxLengthOnStringBuffer("TEST", "TEST", 5);
		this.verifyConvertCamelCaseToAllCapsMaxLengthOnStringBuffer("TE", "TEST", 2);
		this.verifyConvertCamelCaseToAllCapsMaxLengthOnStringBuffer("TEST_TEST", "testTest", 9);
		this.verifyConvertCamelCaseToAllCapsMaxLengthOnStringBuffer("TEST_TES", "testTest", 8);
		this.verifyConvertCamelCaseToAllCapsMaxLengthOnStringBuffer("TEST_T", "testTest", 6);
		this.verifyConvertCamelCaseToAllCapsMaxLengthOnStringBuffer("TEST_", "testTest", 5);
		this.verifyConvertCamelCaseToAllCapsMaxLengthOnStringBuffer("TEST", "testTest", 4);
		this.verifyConvertCamelCaseToAllCapsMaxLengthOnStringBuffer("TEST_TEST", "TestTest", 9);
		this.verifyConvertCamelCaseToAllCapsMaxLengthOnStringBuffer("TEST_TEST", "TestTest", 1100);
		this.verifyConvertCamelCaseToAllCapsMaxLengthOnStringBuffer("TEST_TEST_", "testTESTTest", 10);
		this.verifyConvertCamelCaseToAllCapsMaxLengthOnStringBuffer("TEST_TEST_TEST", "TestTESTTest", 14);
		this.verifyConvertCamelCaseToAllCapsMaxLengthOnStringBuffer("TEST_TEST_TEST_T", "TestTESTTestT", 16);
		this.verifyConvertCamelCaseToAllCapsMaxLengthOnStringBuffer("TEST_TEST_TEST_", "TestTESTTestT", 15);
	}

	private void verifyConvertCamelCaseToAllCapsMaxLengthOnStringBuffer(String expected, String string, int max) {
		StringBuffer sb = new StringBuffer();
		StringTools.convertCamelCaseToAllCapsOn(string, max, sb);
		assertEquals(expected, sb.toString());
	}

	// ********** convert underscores to all-caps **********

	public void testConvertUnderscoresToCamelCase() {
		assertEquals("test", StringTools.convertUnderscoresToCamelCase("TEST", false));
		assertEquals("test", StringTools.convertUnderscoresToCamelCase("TEST_", false));
		assertEquals("test", StringTools.convertUnderscoresToCamelCase("TEST____", false));
		assertEquals("Test", StringTools.convertUnderscoresToCamelCase("TEST", true));
		assertEquals("test", StringTools.convertUnderscoresToCamelCase("TeST", false));
		assertEquals("testTest", StringTools.convertUnderscoresToCamelCase("TEST_TEST", false));
		assertEquals("testTest", StringTools.convertUnderscoresToCamelCase("TEST___TEST", false));
		assertEquals("TestTest", StringTools.convertUnderscoresToCamelCase("TEST_TEST", true));
		assertEquals("testTestTest", StringTools.convertUnderscoresToCamelCase("TEST_TEST_TEST", false));
		assertEquals("TestTestTest", StringTools.convertUnderscoresToCamelCase("TEST_TEST_TEST", true));
		assertEquals("testTestTestT", StringTools.convertUnderscoresToCamelCase("TEST_TEST_TEST_T", false));
		assertEquals("testTestTestT", StringTools.convertUnderscoresToCamelCase("_TEST_TEST_TEST_T", false));
		assertEquals("testTestTestT", StringTools.convertUnderscoresToCamelCase("__TEST_TEST_TEST_T", false));
		assertEquals("TestTestTestT", StringTools.convertUnderscoresToCamelCase("TEST_TEST_TEST_T", true));
		assertEquals("TestTestTestT", StringTools.convertUnderscoresToCamelCase("_TEST_TEST_TEST_T", true));
		assertEquals("TestTestTestT", StringTools.convertUnderscoresToCamelCase("__TEST_TEST_TEST_T", true));
	}

	public void testConvertUnderscoresToCamelCaseLowercase() {
		assertEquals("test", StringTools.convertUnderscoresToCamelCase("test", false));
		assertEquals("test", StringTools.convertUnderscoresToCamelCase("test_", false));
		assertEquals("test", StringTools.convertUnderscoresToCamelCase("test____", false));
		assertEquals("Test", StringTools.convertUnderscoresToCamelCase("test", true));
		assertEquals("test", StringTools.convertUnderscoresToCamelCase("test", false));
		assertEquals("testTest", StringTools.convertUnderscoresToCamelCase("test_test", false));
		assertEquals("testTest", StringTools.convertUnderscoresToCamelCase("test___test", false));
		assertEquals("TestTest", StringTools.convertUnderscoresToCamelCase("test_test", true));
		assertEquals("testTestTest", StringTools.convertUnderscoresToCamelCase("test_test_test", false));
		assertEquals("TestTestTest", StringTools.convertUnderscoresToCamelCase("test_test_test", true));
		assertEquals("testTestTestT", StringTools.convertUnderscoresToCamelCase("test_test_test_t", false));
		assertEquals("testTestTestT", StringTools.convertUnderscoresToCamelCase("_test_test_test_t", false));
		assertEquals("testTestTestT", StringTools.convertUnderscoresToCamelCase("__test_test_test_t", false));
		assertEquals("TestTestTestT", StringTools.convertUnderscoresToCamelCase("test_test_test_t", true));
		assertEquals("TestTestTestT", StringTools.convertUnderscoresToCamelCase("_test_test_test_t", true));
		assertEquals("TestTestTestT", StringTools.convertUnderscoresToCamelCase("__test_test_test_t", true));
	}

	public void testConvertUnderscoresToCamelCaseOnWriter() {
		this.verifyConvertUnderscoresToCamelCaseOnWriter("test", "TEST", false);
		this.verifyConvertUnderscoresToCamelCaseOnWriter("test", "TEST_", false);
		this.verifyConvertUnderscoresToCamelCaseOnWriter("test", "TEST____", false);
		this.verifyConvertUnderscoresToCamelCaseOnWriter("Test", "TEST", true);
		this.verifyConvertUnderscoresToCamelCaseOnWriter("test", "TeST", false);
		this.verifyConvertUnderscoresToCamelCaseOnWriter("testTest", "TEST_TEST", false);
		this.verifyConvertUnderscoresToCamelCaseOnWriter("testTest", "TEST___TEST", false);
		this.verifyConvertUnderscoresToCamelCaseOnWriter("TestTest", "TEST_TEST", true);
		this.verifyConvertUnderscoresToCamelCaseOnWriter("testTestTest", "TEST_TEST_TEST", false);
		this.verifyConvertUnderscoresToCamelCaseOnWriter("TestTestTest", "TEST_TEST_TEST", true);
		this.verifyConvertUnderscoresToCamelCaseOnWriter("testTestTestT", "TEST_TEST_TEST_T", false);
		this.verifyConvertUnderscoresToCamelCaseOnWriter("testTestTestT", "_TEST_TEST_TEST_T", false);
		this.verifyConvertUnderscoresToCamelCaseOnWriter("testTestTestT", "__TEST_TEST_TEST_T", false);
		this.verifyConvertUnderscoresToCamelCaseOnWriter("TestTestTestT", "TEST_TEST_TEST_T", true);
		this.verifyConvertUnderscoresToCamelCaseOnWriter("TestTestTestT", "_TEST_TEST_TEST_T", true);
		this.verifyConvertUnderscoresToCamelCaseOnWriter("TestTestTestT", "__TEST_TEST_TEST_T", true);
	}

	public void testConvertUnderscoresToCamelCaseOnWriterLowercase() {
		this.verifyConvertUnderscoresToCamelCaseOnWriter("test", "test", false);
		this.verifyConvertUnderscoresToCamelCaseOnWriter("test", "test_", false);
		this.verifyConvertUnderscoresToCamelCaseOnWriter("test", "test____", false);
		this.verifyConvertUnderscoresToCamelCaseOnWriter("Test", "test", true);
		this.verifyConvertUnderscoresToCamelCaseOnWriter("test", "test", false);
		this.verifyConvertUnderscoresToCamelCaseOnWriter("testTest", "test_test", false);
		this.verifyConvertUnderscoresToCamelCaseOnWriter("testTest", "test___test", false);
		this.verifyConvertUnderscoresToCamelCaseOnWriter("TestTest", "test_test", true);
		this.verifyConvertUnderscoresToCamelCaseOnWriter("testTestTest", "test_test_test", false);
		this.verifyConvertUnderscoresToCamelCaseOnWriter("TestTestTest", "test_test_test", true);
		this.verifyConvertUnderscoresToCamelCaseOnWriter("testTestTestT", "test_test_test_t", false);
		this.verifyConvertUnderscoresToCamelCaseOnWriter("testTestTestT", "_test_test_test_t", false);
		this.verifyConvertUnderscoresToCamelCaseOnWriter("testTestTestT", "__test_test_test_t", false);
		this.verifyConvertUnderscoresToCamelCaseOnWriter("TestTestTestT", "test_test_test_t", true);
		this.verifyConvertUnderscoresToCamelCaseOnWriter("TestTestTestT", "_test_test_test_t", true);
		this.verifyConvertUnderscoresToCamelCaseOnWriter("TestTestTestT", "__test_test_test_t", true);
	}

	private void verifyConvertUnderscoresToCamelCaseOnWriter(String expected, String string, boolean capitalizeFirstLetter) {
		Writer writer = new StringWriter();
		StringTools.convertUnderscoresToCamelCaseOn(string, capitalizeFirstLetter, writer);
		assertEquals(expected, writer.toString());
	}

	public void testConvertUnderscoresToCamelCaseOnStringBuffer() {
		this.verifyConvertUnderscoresToCamelCaseOnStringBuffer("test", "TEST", false);
		this.verifyConvertUnderscoresToCamelCaseOnStringBuffer("test", "TEST_", false);
		this.verifyConvertUnderscoresToCamelCaseOnStringBuffer("test", "TEST____", false);
		this.verifyConvertUnderscoresToCamelCaseOnStringBuffer("Test", "TEST", true);
		this.verifyConvertUnderscoresToCamelCaseOnStringBuffer("test", "TeST", false);
		this.verifyConvertUnderscoresToCamelCaseOnStringBuffer("testTest", "TEST_TEST", false);
		this.verifyConvertUnderscoresToCamelCaseOnStringBuffer("testTest", "TEST___TEST", false);
		this.verifyConvertUnderscoresToCamelCaseOnStringBuffer("TestTest", "TEST_TEST", true);
		this.verifyConvertUnderscoresToCamelCaseOnStringBuffer("testTestTest", "TEST_TEST_TEST", false);
		this.verifyConvertUnderscoresToCamelCaseOnStringBuffer("TestTestTest", "TEST_TEST_TEST", true);
		this.verifyConvertUnderscoresToCamelCaseOnStringBuffer("testTestTestT", "TEST_TEST_TEST_T", false);
		this.verifyConvertUnderscoresToCamelCaseOnStringBuffer("testTestTestT", "_TEST_TEST_TEST_T", false);
		this.verifyConvertUnderscoresToCamelCaseOnStringBuffer("testTestTestT", "__TEST_TEST_TEST_T", false);
		this.verifyConvertUnderscoresToCamelCaseOnStringBuffer("TestTestTestT", "TEST_TEST_TEST_T", true);
		this.verifyConvertUnderscoresToCamelCaseOnStringBuffer("TestTestTestT", "_TEST_TEST_TEST_T", true);
		this.verifyConvertUnderscoresToCamelCaseOnStringBuffer("TestTestTestT", "__TEST_TEST_TEST_T", true);
	}

	public void testConvertUnderscoresToCamelCaseOnStringBufferLowercase() {
		this.verifyConvertUnderscoresToCamelCaseOnStringBuffer("test", "test", false);
		this.verifyConvertUnderscoresToCamelCaseOnStringBuffer("test", "test_", false);
		this.verifyConvertUnderscoresToCamelCaseOnStringBuffer("test", "test____", false);
		this.verifyConvertUnderscoresToCamelCaseOnStringBuffer("Test", "test", true);
		this.verifyConvertUnderscoresToCamelCaseOnStringBuffer("test", "test", false);
		this.verifyConvertUnderscoresToCamelCaseOnStringBuffer("testTest", "test_test", false);
		this.verifyConvertUnderscoresToCamelCaseOnStringBuffer("testTest", "test___test", false);
		this.verifyConvertUnderscoresToCamelCaseOnStringBuffer("TestTest", "test_test", true);
		this.verifyConvertUnderscoresToCamelCaseOnStringBuffer("testTestTest", "test_test_test", false);
		this.verifyConvertUnderscoresToCamelCaseOnStringBuffer("TestTestTest", "test_test_test", true);
		this.verifyConvertUnderscoresToCamelCaseOnStringBuffer("testTestTestT", "test_test_test_t", false);
		this.verifyConvertUnderscoresToCamelCaseOnStringBuffer("testTestTestT", "_test_test_test_t", false);
		this.verifyConvertUnderscoresToCamelCaseOnStringBuffer("testTestTestT", "__test_test_test_t", false);
		this.verifyConvertUnderscoresToCamelCaseOnStringBuffer("TestTestTestT", "test_test_test_t", true);
		this.verifyConvertUnderscoresToCamelCaseOnStringBuffer("TestTestTestT", "_test_test_test_t", true);
		this.verifyConvertUnderscoresToCamelCaseOnStringBuffer("TestTestTestT", "__test_test_test_t", true);
	}

	private void verifyConvertUnderscoresToCamelCaseOnStringBuffer(String expected, String string, boolean capitalizeFirstLetter) {
		StringBuffer sb = new StringBuffer();
		StringTools.convertUnderscoresToCamelCaseOn(string, capitalizeFirstLetter, sb);
		assertEquals(expected, sb.toString());
	}

	// ********** delimiting **********

	public void testStringIsQuoted() {
		this.denyStringIsQuoted("foo");
		this.verifyStringIsQuoted("\"foo\"");

		this.denyStringIsQuoted("");
		this.verifyStringIsQuoted("\"\"");

		this.denyStringIsQuoted("\"");
		this.denyStringIsQuoted(" ");
		this.denyStringIsQuoted("''");
		this.denyStringIsQuoted("'foo'");
	}

	private void verifyStringIsQuoted(String s) {
		assertTrue(StringTools.stringIsQuoted(s));
		assertTrue(StringTools.stringIsQuoted(s.toCharArray()));
	}

	private void denyStringIsQuoted(String s) {
		assertFalse(StringTools.stringIsQuoted(s));
		assertFalse(StringTools.stringIsQuoted(s.toCharArray()));
	}

	public void testStringIsParenthetical() {
		this.denyStringIsParenthetical("foo");
		this.verifyStringIsParenthetical("(foo)");

		this.denyStringIsParenthetical("");
		this.verifyStringIsParenthetical("()");

		this.denyStringIsParenthetical("(");
		this.denyStringIsParenthetical(" ");
		this.denyStringIsParenthetical("''");
		this.denyStringIsParenthetical("'foo'");
	}

	private void verifyStringIsParenthetical(String s) {
		assertTrue(StringTools.stringIsParenthetical(s));
		assertTrue(StringTools.stringIsParenthetical(s.toCharArray()));
	}

	private void denyStringIsParenthetical(String s) {
		assertFalse(StringTools.stringIsParenthetical(s));
		assertFalse(StringTools.stringIsParenthetical(s.toCharArray()));
	}

	public void testStringIsBracketed() {
		this.denyStringIsBracketed("foo");
		this.verifyStringIsBracketed("[foo]");

		this.denyStringIsBracketed("");
		this.verifyStringIsBracketed("[]");

		this.denyStringIsBracketed("[");
		this.denyStringIsBracketed(" ");
		this.denyStringIsBracketed("''");
		this.denyStringIsBracketed("'foo'");
	}

	private void verifyStringIsBracketed(String s) {
		assertTrue(StringTools.stringIsBracketed(s));
		assertTrue(StringTools.stringIsBracketed(s.toCharArray()));
	}

	private void denyStringIsBracketed(String s) {
		assertFalse(StringTools.stringIsBracketed(s));
		assertFalse(StringTools.stringIsBracketed(s.toCharArray()));
	}

	public void testStringIsBraced() {
		this.denyStringIsBraced("foo");
		this.verifyStringIsBraced("{foo}");

		this.denyStringIsBraced("");
		this.verifyStringIsBraced("{}");

		this.denyStringIsBraced("{");
		this.denyStringIsBraced(" ");
		this.denyStringIsBraced("''");
		this.denyStringIsBraced("'foo'");
	}

	private void verifyStringIsBraced(String s) {
		assertTrue(StringTools.stringIsBraced(s));
		assertTrue(StringTools.stringIsBraced(s.toCharArray()));
	}

	private void denyStringIsBraced(String s) {
		assertFalse(StringTools.stringIsBraced(s));
		assertFalse(StringTools.stringIsBraced(s.toCharArray()));
	}

	public void testStringIsChevroned() {
		this.denyStringIsChevroned("foo");
		this.verifyStringIsChevroned("<foo>");

		this.denyStringIsChevroned("");
		this.verifyStringIsChevroned("<>");

		this.denyStringIsChevroned("{");
		this.denyStringIsChevroned(" ");
		this.denyStringIsChevroned("''");
		this.denyStringIsChevroned("'foo'");
	}

	private void verifyStringIsChevroned(String s) {
		assertTrue(StringTools.stringIsChevroned(s));
		assertTrue(StringTools.stringIsChevroned(s.toCharArray()));
	}

	private void denyStringIsChevroned(String s) {
		assertFalse(StringTools.stringIsChevroned(s));
		assertFalse(StringTools.stringIsChevroned(s.toCharArray()));
	}

	public void testStringIsDelimited() {
		this.denyStringIsDelimited("foo", '?');
		this.verifyStringIsDelimited("?foo?", '?');

		this.denyStringIsDelimited("", '?');
		this.verifyStringIsDelimited("\"\"", '"');
		this.verifyStringIsDelimited("?xx?", '?');
		this.denyStringIsDelimited("?xx]", '?');

		this.denyStringIsDelimited("\"", '"');
		this.denyStringIsDelimited(" ", ' ');
		this.denyStringIsDelimited("''", '"');
		this.denyStringIsDelimited("'foo'", '?');
	}

	private void verifyStringIsDelimited(String s, char c) {
		assertTrue(StringTools.stringIsDelimited(s, c));
		assertTrue(StringTools.stringIsDelimited(s.toCharArray(), c));
	}

	private void denyStringIsDelimited(String s, char c) {
		assertFalse(StringTools.stringIsDelimited(s, c));
		assertFalse(StringTools.stringIsDelimited(s.toCharArray(), c));
	}

	public void testStringIsDelimited2() {
		this.denyStringIsDelimited2("foo", '[', ']');
		this.verifyStringIsDelimited2("{foo}", '{', '}');

		this.denyStringIsDelimited2("", '[', ']');
		this.verifyStringIsDelimited2("[]", '[', ']');
		this.verifyStringIsDelimited2("[xx]", '[', ']');
		this.denyStringIsDelimited2("?xx]", '[', ']');

		this.denyStringIsDelimited2("\"", '[', ']');
		this.denyStringIsDelimited2(" ", '[', ']');
		this.denyStringIsDelimited2("''", '[', ']');
		this.denyStringIsDelimited2("'foo'", '[', ']');
	}

	private void verifyStringIsDelimited2(String s, char start, char end) {
		assertTrue(StringTools.stringIsDelimited(s, start, end));
		assertTrue(StringTools.stringIsDelimited(s.toCharArray(), start, end));
	}

	private void denyStringIsDelimited2(String s, char start, char end) {
		assertFalse(StringTools.stringIsDelimited(s, start, end));
		assertFalse(StringTools.stringIsDelimited(s.toCharArray(), start, end));
	}

	// ********** undelimiting **********

	public void testUndelimit() {
		this.verifyUndelimit("\"foo\"", "foo");
		this.verifyUndelimit("\"\"", "");
		this.verifyUndelimit("'foo'", "foo");
		this.verifyUndelimit("\"fo\"\"o\"", "fo\"o");
		this.verifyUndelimit("\"foo\"\"\"", "foo\"");
		this.verifyUndelimit("\"\"\"foo\"", "\"foo");
		this.verifyUndelimit("[foo]", "foo");
		this.verifyUndelimit("\"\"\"", "\"");
		this.verifyUndelimit("\"foo\"bar\"", "foo\"");
		this.verifyUndelimit("\"foo\"\"", "foo\"");
	}

	private void verifyUndelimit(String s, String expected) {
		assertEquals(expected, StringTools.undelimit(s));
		assertEquals(expected, StringTools.undelimit(s.toCharArray()));
	}

	public void testUndelimitInt() {
		this.verifyUndelimitInt("\"foo\"", 2, "o");
		this.verifyUndelimitInt("\"\"foo\"\"", 2, "foo");
		this.verifyUndelimitInt("'foo'", 2, "o");
	}

	private void verifyUndelimitInt(String s, int count, String expected) {
		assertEquals(expected, StringTools.undelimit(s, count));
		assertEquals(expected, StringTools.undelimit(s.toCharArray(), count));
	}

	public void testUndelimitIntException() {
		this.denyUndelimitInt("\"\"", 2);
		this.denyUndelimitInt("'o'", 2);
	}

	private void denyUndelimitInt(String s, int count) {
		boolean exCaught = false;
		try {
			String bogus = StringTools.undelimit(s, count);
			fail("invalid string: " + bogus);
		} catch (IllegalArgumentException ex) {
			exCaught = true;
		}
		assertTrue(exCaught);

		exCaught = false;
		try {
			char[] bogus = StringTools.undelimit(s.toCharArray(), count);
			fail("invalid string: " + new String(bogus));
		} catch (IllegalArgumentException ex) {
			exCaught = true;
		}
		assertTrue(exCaught);
	}

	public void testUndelimitOnWriter() {
		this.verifyUndelimitOnWriter("\"foo\"", "foo");
		this.verifyUndelimitOnWriter("\"\"", "");
		this.verifyUndelimitOnWriter("'foo'", "foo");
		this.verifyUndelimitOnWriter("\"fo\"\"o\"", "fo\"o");
		this.verifyUndelimitOnWriter("\"foo\"\"\"", "foo\"");
		this.verifyUndelimitOnWriter("\"\"\"foo\"", "\"foo");
		this.verifyUndelimitOnWriter("[foo]", "foo");
		this.verifyUndelimitOnWriter("\"\"\"", "\"");
		this.verifyUndelimitOnWriter("\"foo\"bar\"", "foo\"");
		this.verifyUndelimitOnWriter("\"foo\"\"", "foo\"");
	}

	private void verifyUndelimitOnWriter(String s, String expected) {
		Writer writer = new StringWriter();
		StringTools.undelimitOn(s, writer);
		assertEquals(expected, writer.toString());

		writer = new StringWriter();
		StringTools.undelimitOn(s.toCharArray(), writer);
		assertEquals(expected, writer.toString());
	}

	public void testUndelimitOnStringBuffer() {
		this.verifyUndelimitOnStringBuffer("\"foo\"", "foo");
		this.verifyUndelimitOnStringBuffer("\"\"", "");
		this.verifyUndelimitOnStringBuffer("'foo'", "foo");
		this.verifyUndelimitOnStringBuffer("\"fo\"\"o\"", "fo\"o");
		this.verifyUndelimitOnStringBuffer("\"foo\"\"\"", "foo\"");
		this.verifyUndelimitOnStringBuffer("\"\"\"foo\"", "\"foo");
		this.verifyUndelimitOnStringBuffer("[foo]", "foo");
		this.verifyUndelimitOnStringBuffer("\"\"\"", "\"");
		this.verifyUndelimitOnStringBuffer("\"foo\"bar\"", "foo\"");
		this.verifyUndelimitOnStringBuffer("\"foo\"\"", "foo\"");
	}

	private void verifyUndelimitOnStringBuffer(String s, String expected) {
		StringBuffer sb = new StringBuffer();
		StringTools.undelimitOn(s, sb);
		assertEquals(expected, sb.toString());

		sb = new StringBuffer();
		StringTools.undelimitOn(s.toCharArray(), sb);
		assertEquals(expected, sb.toString());
	}

	public void testUndelimitOnStringBuilder() {
		this.verifyUndelimitOnStringBuilder("\"foo\"", "foo");
		this.verifyUndelimitOnStringBuilder("\"\"", "");
		this.verifyUndelimitOnStringBuilder("'foo'", "foo");
		this.verifyUndelimitOnStringBuilder("\"fo\"\"o\"", "fo\"o");
		this.verifyUndelimitOnStringBuilder("\"foo\"\"\"", "foo\"");
		this.verifyUndelimitOnStringBuilder("\"\"\"foo\"", "\"foo");
		this.verifyUndelimitOnStringBuilder("[foo]", "foo");
		this.verifyUndelimitOnStringBuilder("\"\"\"", "\"");
		this.verifyUndelimitOnStringBuilder("\"foo\"bar\"", "foo\"");
		this.verifyUndelimitOnStringBuilder("\"foo\"\"", "foo\"");
	}

	private void verifyUndelimitOnStringBuilder(String s, String expected) {
		StringBuilder sb = new StringBuilder();
		StringTools.undelimitOn(s, sb);
		assertEquals(expected, sb.toString());

		sb = new StringBuilder();
		StringTools.undelimitOn(s.toCharArray(), sb);
		assertEquals(expected, sb.toString());
	}

	public void testUndelimitOnWriterCount() {
		this.verifyUndelimitOnWriterCount("\"foo\"", 2, "o");
		this.verifyUndelimitOnWriterCount("\"\"\"\"", 2, "");
		this.verifyUndelimitOnWriterCount("XXfooXX", 2, "foo");
	}

	private void verifyUndelimitOnWriterCount(String s, int count, String expected) {
		Writer writer = new StringWriter();
		StringTools.undelimitOn(s, count, writer);
		assertEquals(expected, writer.toString());

		writer = new StringWriter();
		StringTools.undelimitOn(s.toCharArray(), count, writer);
		assertEquals(expected, writer.toString());
	}

	public void testUndelimitOnStringBufferCount() {
		this.verifyUndelimitOnStringBufferCount("\"foo\"", 2, "o");
		this.verifyUndelimitOnStringBufferCount("\"\"\"\"", 2, "");
		this.verifyUndelimitOnStringBufferCount("XXfooXX", 2, "foo");
	}

	private void verifyUndelimitOnStringBufferCount(String s, int count, String expected) {
		StringBuffer sb = new StringBuffer();
		StringTools.undelimitOn(s, count, sb);
		assertEquals(expected, sb.toString());

		sb = new StringBuffer();
		StringTools.undelimitOn(s.toCharArray(), count, sb);
		assertEquals(expected, sb.toString());
	}

	public void testUndelimitOnStringBuilderCount() {
		this.verifyUndelimitOnStringBuilderCount("\"foo\"", 2, "o");
		this.verifyUndelimitOnStringBuilderCount("\"\"\"\"", 2, "");
		this.verifyUndelimitOnStringBuilderCount("XXfooXX", 2, "foo");
	}

	private void verifyUndelimitOnStringBuilderCount(String s, int count, String expected) {
		StringBuilder sb = new StringBuilder();
		StringTools.undelimitOn(s, count, sb);
		assertEquals(expected, sb.toString());

		sb = new StringBuilder();
		StringTools.undelimitOn(s.toCharArray(), count, sb);
		assertEquals(expected, sb.toString());
	}

	// ********** converting to Java string literal **********

	public void testConvertToJavaStringLiteral() {
		this.verifyConvertToJavaStringLiteral("", "\"\"");
		this.verifyConvertToJavaStringLiteral("\"\"", "\"\\\"\\\"\"");
		this.verifyConvertToJavaStringLiteral("'foo'", "\"'foo'\"");
		this.verifyConvertToJavaStringLiteral("foo\bbar", "\"foo\\bbar\"");
		this.verifyConvertToJavaStringLiteral("foo\n\tbar", "\"foo\\n\\tbar\"");
		this.verifyConvertToJavaStringLiteral("foo\"bar", "\"foo\\\"bar\"");
		this.verifyConvertToJavaStringLiteral("foo\\bar", "\"foo\\\\bar\"");
	}

	private void verifyConvertToJavaStringLiteral(String s, String expected) {
		assertEquals(expected, StringTools.convertToJavaStringLiteral(s));
		assertEquals(expected, StringTools.convertToJavaStringLiteral(s.toCharArray()));
	}

	public void testConvertToJavaStringLiteralOnStringBuffer() {
		this.verifyConvertToJavaStringLiteralOnStringBuffer("", "\"\"");
		this.verifyConvertToJavaStringLiteralOnStringBuffer("\"\"", "\"\\\"\\\"\"");
		this.verifyConvertToJavaStringLiteralOnStringBuffer("'foo'", "\"'foo'\"");
		this.verifyConvertToJavaStringLiteralOnStringBuffer("foo\bbar", "\"foo\\bbar\"");
		this.verifyConvertToJavaStringLiteralOnStringBuffer("foo\n\tbar", "\"foo\\n\\tbar\"");
		this.verifyConvertToJavaStringLiteralOnStringBuffer("foo\"bar", "\"foo\\\"bar\"");
		this.verifyConvertToJavaStringLiteralOnStringBuffer("foo\\bar", "\"foo\\\\bar\"");
	}

	private void verifyConvertToJavaStringLiteralOnStringBuffer(String s, String expected) {
		StringBuffer sb = new StringBuffer();
		StringTools.convertToJavaStringLiteralOn(s, sb);
		assertEquals(expected, sb.toString());

		sb = new StringBuffer();
		StringTools.convertToJavaStringLiteralOn(s.toCharArray(), sb);
		assertEquals(expected, sb.toString());
	}

	public void testConvertToJavaStringLiteralOnStringBuilder() {
		this.verifyConvertToJavaStringLiteralOnStringBuilder("", "\"\"");
		this.verifyConvertToJavaStringLiteralOnStringBuilder("\"\"", "\"\\\"\\\"\"");
		this.verifyConvertToJavaStringLiteralOnStringBuilder("'foo'", "\"'foo'\"");
		this.verifyConvertToJavaStringLiteralOnStringBuilder("foo\bbar", "\"foo\\bbar\"");
		this.verifyConvertToJavaStringLiteralOnStringBuilder("foo\n\tbar", "\"foo\\n\\tbar\"");
		this.verifyConvertToJavaStringLiteralOnStringBuilder("foo\"bar", "\"foo\\\"bar\"");
		this.verifyConvertToJavaStringLiteralOnStringBuilder("foo\\bar", "\"foo\\\\bar\"");
	}

	private void verifyConvertToJavaStringLiteralOnStringBuilder(String s, String expected) {
		StringBuilder sb = new StringBuilder();
		StringTools.convertToJavaStringLiteralOn(s, sb);
		assertEquals(expected, sb.toString());

		sb = new StringBuilder();
		StringTools.convertToJavaStringLiteralOn(s.toCharArray(), sb);
		assertEquals(expected, sb.toString());
	}

	public void testConvertToJavaStringLiteralOnWriter() {
		this.verifyConvertToJavaStringLiteralOnWriter("", "\"\"");
		this.verifyConvertToJavaStringLiteralOnWriter("\"\"", "\"\\\"\\\"\"");
		this.verifyConvertToJavaStringLiteralOnWriter("'foo'", "\"'foo'\"");
		this.verifyConvertToJavaStringLiteralOnWriter("foo\bbar", "\"foo\\bbar\"");
		this.verifyConvertToJavaStringLiteralOnWriter("foo\n\tbar", "\"foo\\n\\tbar\"");
		this.verifyConvertToJavaStringLiteralOnWriter("foo\"bar", "\"foo\\\"bar\"");
		this.verifyConvertToJavaStringLiteralOnWriter("foo\\bar", "\"foo\\\\bar\"");
	}

	private void verifyConvertToJavaStringLiteralOnWriter(String s, String expected) {
		Writer writer = new StringWriter();
		StringTools.convertToJavaStringLiteralOn(s, writer);
		assertEquals(expected, writer.toString());

		writer = new StringWriter();
		StringTools.convertToJavaStringLiteralOn(s.toCharArray(), writer);
		assertEquals(expected, writer.toString());
	}

}