common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/io/WriterToolsTests.java - dali/webtools.dali - Git at Google

 /*******************************************************************************
  * Copyright (c) 2005, 2012 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.common.utility.tests.internal.io;

 import java.io.StringWriter;
 import java.io.Writer;
 import junit.framework.TestCase;
 import org.eclipse.jpt.common.utility.internal.io.WriterTools;
 import org.eclipse.jpt.common.utility.tests.internal.StringToolsTests;

 @SuppressWarnings("nls")
 public class WriterToolsTests
 	extends TestCase
 {
 	public WriterToolsTests(String name) {
 		super(name);
 	}

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

 	public void testCenter() throws Exception {
 		this.verifyCenter("fred", "fred", 4);
 		this.verifyCenter(" fred ", "fred", 6);
 		this.verifyCenter(" fred  ", "fred", 7);
 		this.verifyCenter("re", "fred", 2);
 		this.verifyCenter("fre", "fred", 3);
 	}

 	private void verifyCenter(String expected, String s, int len) throws Exception {
 		Writer writer;
 		writer = new StringWriter();
 		WriterTools.center(writer, s, len);
 		assertEquals(expected, writer.toString());

 		writer = new StringWriter();
 		WriterTools.center(writer, s.toCharArray(), len);
 		assertEquals(expected, writer.toString());
 	}

 	public void testPad() throws Exception {
 		Writer writer;
 		writer = new StringWriter();
 		WriterTools.pad(writer, "fred", 4);
 		assertEquals("fred", writer.toString());

 		writer = new StringWriter();
 		WriterTools.pad(writer, "fred", 6);
 		assertEquals("fred  ", writer.toString());

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

 	public void testFit() throws Exception {
 		this.verifyFit("fred", "fred", 4);
 		this.verifyFit("fred  ", "fred", 6);
 		this.verifyFit("fr", "fred", 2);
 	}

 	private void verifyFit(String expected, String string, int length) throws Exception {
 		Writer writer = new StringWriter();
 		WriterTools.fit(writer, string, length);
 		assertEquals(expected, writer.toString());
 	}

 	public void testZeroPad() throws Exception {
 		Writer writer;
 		writer = new StringWriter();
 		WriterTools.zeroPad(writer, "1234", 4);
 		assertEquals("1234", writer.toString());

 		writer = new StringWriter();
 		WriterTools.zeroPad(writer, "1234", 6);
 		assertEquals("001234", writer.toString());

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

 	public void testZeroFit() throws Exception {
 		this.verifyZeroFit("1234", "1234", 4);
 		this.verifyZeroFit("001234", "1234", 6);
 		this.verifyZeroFit("34", "1234", 2);
 	}

 	private void verifyZeroFit(String expected, String string, int length) throws Exception {
 		Writer writer = new StringWriter();
 		WriterTools.zeroFit(writer, string, length);
 		assertEquals(expected, writer.toString());
 	}

 	public void testSeparateOnStringCharInt() throws Exception {
 		this.verifySeparate("012345", '-', 22, "012345");
 		this.verifySeparate("012345", '-',  6, "012345");
 		this.verifySeparate("012345", '-',  5, "01234-5");
 		this.verifySeparate("012345", '-',  4, "0123-45");
 		this.verifySeparate("012345", '-',  3, "012-345");
 		this.verifySeparate("012345", '-',  2, "01-23-45");
 		this.verifySeparate("012345", '-',  1, "0-1-2-3-4-5");
 	}

 	private void verifySeparate(String string, char separator, int segmentLength, String expected) throws Exception {
 		Writer writer = new StringWriter();
 		WriterTools.separate(writer, string, separator, segmentLength);
 		assertEquals(expected, writer.toString());
 	}

 	public void testSeparateOnCharArrayCharInt() throws Exception {
 		this.verifySeparateCharArray("012345", '-', 22, "012345");
 		this.verifySeparateCharArray("012345", '-',  6, "012345");
 		this.verifySeparateCharArray("012345", '-',  5, "01234-5");
 		this.verifySeparateCharArray("012345", '-',  4, "0123-45");
 		this.verifySeparateCharArray("012345", '-',  3, "012-345");
 		this.verifySeparateCharArray("012345", '-',  2, "01-23-45");
 		this.verifySeparateCharArray("012345", '-',  1, "0-1-2-3-4-5");
 	}

 	private void verifySeparateCharArray(String string, char separator, int segmentLength, String expected) throws Exception {
 		Writer writer = new StringWriter();
 		WriterTools.separate(writer, string.toCharArray(), separator, segmentLength);
 		assertEquals(expected, writer.toString());
 	}

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

 	private void verifyDelimit(String string, String delimiter, String expectedString) throws Exception {
 		Writer writer = new StringWriter();
 		WriterTools.delimit(writer, string, delimiter);
 		assertEquals(expectedString, writer.toString());
 	}

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

 	private void verifyQuote(String string, String expectedString) throws Exception {
 		Writer writer = new StringWriter();
 		WriterTools.quote(writer, string);
 		assertEquals(expectedString, writer.toString());
 	}

 	public void testRemoveFirstOccurrence() throws Exception {
 		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) throws Exception {
 		Writer writer = new StringWriter();
 		WriterTools.removeFirstOccurrence(writer, string, charToRemove);
 		assertEquals(expectedString, writer.toString());
 	}

 	public void testRemoveAllOccurrences() throws Exception {
 		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) throws Exception {
 		Writer writer = new StringWriter();
 		WriterTools.removeAllOccurrences(writer, string, charToRemove);
 		assertEquals(expectedString, writer.toString());
 	}

 	public void testRemoveAllWhitespace() throws Exception {
 		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) throws Exception {
 		Writer writer = new StringWriter();
 		WriterTools.removeAllWhitespace(writer, string);
 		assertEquals(expectedString, writer.toString());
 	}

 	public void testCompressWhitespace() throws Exception {
 		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) throws Exception {
 		Writer writer = new StringWriter();
 		WriterTools.compressWhitespace(writer, string);
 		assertEquals(expectedString, writer.toString());
 	}

 	public void testCapitalizeOnStringWriter() throws Exception {
 		this.verifyCapitalizeOnStringWriter("Oracle", "Oracle");
 		this.verifyCapitalizeOnStringWriter("Oracle", "oracle");
 		this.verifyCapitalizeOnStringWriter("   ", "   ");
 		this.verifyCapitalizeOnStringWriter("ORACLE", "ORACLE");
 		this.verifyCapitalizeOnStringWriter("", "");
 		this.verifyCapitalizeOnStringWriter("A", "a");
 		this.verifyCapitalizeOnStringWriter("\u00C9cole", "\u00E9cole"); // e'cole -> E'cole
 	}

 	private void verifyCapitalizeOnStringWriter(String expected, String string) throws Exception {
 		Writer writer = new StringWriter();
 		WriterTools.capitalize(writer, string);
 		assertEquals(expected, writer.toString());
 	}

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

 	private void verifyCapitalizeOnCharArray(String expected, char[] string) throws Exception {
 		Writer writer = new StringWriter();
 		WriterTools.capitalize(writer, string);
 		assertEquals(expected, writer.toString());
 	}

 	public void testUncapitalizeOnStringWriter() throws Exception {
 		this.verifyUncapitalizeOnStringWriter("oracle", "Oracle");
 		this.verifyUncapitalizeOnStringWriter("oracle", "oracle");
 		this.verifyUncapitalizeOnStringWriter("   ", "   ");
 		this.verifyUncapitalizeOnStringWriter("ORACLE", "ORACLE");
 		this.verifyUncapitalizeOnStringWriter("", "");
 		this.verifyUncapitalizeOnStringWriter("a", "A");
 		this.verifyUncapitalizeOnStringWriter("\u00E9cole", "\u00C9cole"); // E'cole -> e'cole
 	}

 	private void verifyUncapitalizeOnStringWriter(String expected, String string) throws Exception {
 		Writer writer = new StringWriter();
 		WriterTools.uncapitalize(writer, string);
 		assertEquals(expected, writer.toString());
 	}

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

 	private void verifyUncapitalizeOnCharArray(String expected, char[] string) throws Exception {
 		Writer writer = new StringWriter();
 		WriterTools.uncapitalize(writer, string);
 		assertEquals(expected, writer.toString());
 	}

 	public void testConvertToHexString() throws Exception {
 		this.verifyConvertToHexString("74657374", "test"); // UTF-8 values
 	}

 	public void testConvertToHexString_negative() throws Exception {
 		this.verifyConvertToHexString(this.getHexCafe(), "caf\u00E9"); // UTF-8 values
 	}

 	private String getHexCafe() {
 		return StringToolsTests.getHexCafe();
 	}

 	private void verifyConvertToHexString(String expected, String string) throws Exception {
 		Writer sb = new StringWriter();
 		WriterTools.convertToHexString(sb, string.getBytes());
 		assertEquals(expected, sb.toString());
 	}

 	public void testConvertCamelCaseToAllCaps() throws Exception {
 		this.verifyConvertCamelCaseToAllCaps("TEST", "test");
 		this.verifyConvertCamelCaseToAllCaps("TEST", "TEST");
 		this.verifyConvertCamelCaseToAllCaps("TEST_TEST", "testTest");
 		this.verifyConvertCamelCaseToAllCaps("TEST_TEST", "TestTest");
 		this.verifyConvertCamelCaseToAllCaps("TEST_TEST_TEST", "testTESTTest");
 		this.verifyConvertCamelCaseToAllCaps("TEST_TEST_TEST", "TestTESTTest");
 		this.verifyConvertCamelCaseToAllCaps("TEST_TEST_TEST_T", "TestTESTTestT");
 	}

 	private void verifyConvertCamelCaseToAllCaps(String expected, String string) throws Exception {
 		Writer writer = new StringWriter();
 		WriterTools.convertCamelCaseToAllCaps(writer, string);
 		assertEquals(expected, writer.toString());
 	}

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

 	private void verifyConvertCamelCaseToAllCapsMaxLength(String expected, String string, int max) throws Exception {
 		Writer writer = new StringWriter();
 		WriterTools.convertCamelCaseToAllCaps(writer, string, max);
 		assertEquals(expected, writer.toString());
 	}

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

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

 	private void verifyConvertUnderscoresToCamelCase(String expected, String string, boolean capitalizeFirstLetter) throws Exception {
 		Writer writer = new StringWriter();
 		WriterTools.convertAllCapsToCamelCase(writer, string, capitalizeFirstLetter);
 		assertEquals(expected, writer.toString());
 	}

 	public void testUndelimit() throws Exception {
 		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) throws Exception {
 		Writer writer = new StringWriter();
 		WriterTools.undelimit(writer, s);
 		assertEquals(expected, writer.toString());

 		writer = new StringWriter();
 		WriterTools.undelimit(writer, s.toCharArray());
 		assertEquals(expected, writer.toString());
 	}

 	public void testUndelimitCount() throws Exception {
 		this.verifyUndelimitCount("\"foo\"", 2, "o");
 		this.verifyUndelimitCount("\"\"\"\"", 2, "");
 		this.verifyUndelimitCount("XXfooXX", 2, "foo");
 	}

 	private void verifyUndelimitCount(String s, int count, String expected) throws Exception {
 		Writer writer = new StringWriter();
 		WriterTools.undelimit(writer, s, count);
 		assertEquals(expected, writer.toString());

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

 	public void testConvertToJavaStringLiteral() throws Exception {
 		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) throws Exception {
 		Writer writer = new StringWriter();
 		WriterTools.convertToJavaStringLiteral(writer, s);
 		assertEquals(expected, writer.toString());

 		writer = new StringWriter();
 		WriterTools.convertToJavaStringLiteral(writer, s.toCharArray());
 		assertEquals(expected, writer.toString());
 	}

 	public void testConvertToJavaStringLiteralContent() throws Exception {
 		this.verifyConvertToJavaStringLiteralContent("", "");
 		this.verifyConvertToJavaStringLiteralContent("\"\"", "\\\"\\\"");
 		this.verifyConvertToJavaStringLiteralContent("'foo'", "'foo'");
 		this.verifyConvertToJavaStringLiteralContent("foo\bbar", "foo\\bbar");
 		this.verifyConvertToJavaStringLiteralContent("foo\n\tbar", "foo\\n\\tbar");
 		this.verifyConvertToJavaStringLiteralContent("foo\"bar", "foo\\\"bar");
 		this.verifyConvertToJavaStringLiteralContent("foo\\bar", "foo\\\\bar");
 	}

 	private void verifyConvertToJavaStringLiteralContent(String s, String expected) throws Exception {
 		Writer writer = new StringWriter();
 		WriterTools.convertToJavaStringLiteralContent(writer, s);
 		assertEquals(expected, writer.toString());

 		writer = new StringWriter();
 		WriterTools.convertToJavaStringLiteralContent(writer, s.toCharArray());
 		assertEquals(expected, writer.toString());
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2005, 2012 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.common.utility.tests.internal.io;

	import java.io.StringWriter;
	import java.io.Writer;
	import junit.framework.TestCase;
	import org.eclipse.jpt.common.utility.internal.io.WriterTools;
	import org.eclipse.jpt.common.utility.tests.internal.StringToolsTests;

	@SuppressWarnings("nls")
	public class WriterToolsTests
	extends TestCase
	{
	public WriterToolsTests(String name) {
	super(name);
	}

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

	public void testCenter() throws Exception {
	this.verifyCenter("fred", "fred", 4);
	this.verifyCenter(" fred ", "fred", 6);
	this.verifyCenter(" fred ", "fred", 7);
	this.verifyCenter("re", "fred", 2);
	this.verifyCenter("fre", "fred", 3);
	}

	private void verifyCenter(String expected, String s, int len) throws Exception {
	Writer writer;
	writer = new StringWriter();
	WriterTools.center(writer, s, len);
	assertEquals(expected, writer.toString());

	writer = new StringWriter();
	WriterTools.center(writer, s.toCharArray(), len);
	assertEquals(expected, writer.toString());
	}

	public void testPad() throws Exception {
	Writer writer;
	writer = new StringWriter();
	WriterTools.pad(writer, "fred", 4);
	assertEquals("fred", writer.toString());

	writer = new StringWriter();
	WriterTools.pad(writer, "fred", 6);
	assertEquals("fred ", writer.toString());

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

	public void testFit() throws Exception {
	this.verifyFit("fred", "fred", 4);
	this.verifyFit("fred ", "fred", 6);
	this.verifyFit("fr", "fred", 2);
	}

	private void verifyFit(String expected, String string, int length) throws Exception {
	Writer writer = new StringWriter();
	WriterTools.fit(writer, string, length);
	assertEquals(expected, writer.toString());
	}

	public void testZeroPad() throws Exception {
	Writer writer;
	writer = new StringWriter();
	WriterTools.zeroPad(writer, "1234", 4);
	assertEquals("1234", writer.toString());

	writer = new StringWriter();
	WriterTools.zeroPad(writer, "1234", 6);
	assertEquals("001234", writer.toString());

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

	public void testZeroFit() throws Exception {
	this.verifyZeroFit("1234", "1234", 4);
	this.verifyZeroFit("001234", "1234", 6);
	this.verifyZeroFit("34", "1234", 2);
	}

	private void verifyZeroFit(String expected, String string, int length) throws Exception {
	Writer writer = new StringWriter();
	WriterTools.zeroFit(writer, string, length);
	assertEquals(expected, writer.toString());
	}

	public void testSeparateOnStringCharInt() throws Exception {
	this.verifySeparate("012345", '-', 22, "012345");
	this.verifySeparate("012345", '-', 6, "012345");
	this.verifySeparate("012345", '-', 5, "01234-5");
	this.verifySeparate("012345", '-', 4, "0123-45");
	this.verifySeparate("012345", '-', 3, "012-345");
	this.verifySeparate("012345", '-', 2, "01-23-45");
	this.verifySeparate("012345", '-', 1, "0-1-2-3-4-5");
	}

	private void verifySeparate(String string, char separator, int segmentLength, String expected) throws Exception {
	Writer writer = new StringWriter();
	WriterTools.separate(writer, string, separator, segmentLength);
	assertEquals(expected, writer.toString());
	}

	public void testSeparateOnCharArrayCharInt() throws Exception {
	this.verifySeparateCharArray("012345", '-', 22, "012345");
	this.verifySeparateCharArray("012345", '-', 6, "012345");
	this.verifySeparateCharArray("012345", '-', 5, "01234-5");
	this.verifySeparateCharArray("012345", '-', 4, "0123-45");
	this.verifySeparateCharArray("012345", '-', 3, "012-345");
	this.verifySeparateCharArray("012345", '-', 2, "01-23-45");
	this.verifySeparateCharArray("012345", '-', 1, "0-1-2-3-4-5");
	}

	private void verifySeparateCharArray(String string, char separator, int segmentLength, String expected) throws Exception {
	Writer writer = new StringWriter();
	WriterTools.separate(writer, string.toCharArray(), separator, segmentLength);
	assertEquals(expected, writer.toString());
	}

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

	private void verifyDelimit(String string, String delimiter, String expectedString) throws Exception {
	Writer writer = new StringWriter();
	WriterTools.delimit(writer, string, delimiter);
	assertEquals(expectedString, writer.toString());
	}

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

	private void verifyQuote(String string, String expectedString) throws Exception {
	Writer writer = new StringWriter();
	WriterTools.quote(writer, string);
	assertEquals(expectedString, writer.toString());
	}

	public void testRemoveFirstOccurrence() throws Exception {
	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) throws Exception {
	Writer writer = new StringWriter();
	WriterTools.removeFirstOccurrence(writer, string, charToRemove);
	assertEquals(expectedString, writer.toString());
	}

	public void testRemoveAllOccurrences() throws Exception {
	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) throws Exception {
	Writer writer = new StringWriter();
	WriterTools.removeAllOccurrences(writer, string, charToRemove);
	assertEquals(expectedString, writer.toString());
	}

	public void testRemoveAllWhitespace() throws Exception {
	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) throws Exception {
	Writer writer = new StringWriter();
	WriterTools.removeAllWhitespace(writer, string);
	assertEquals(expectedString, writer.toString());
	}

	public void testCompressWhitespace() throws Exception {
	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) throws Exception {
	Writer writer = new StringWriter();
	WriterTools.compressWhitespace(writer, string);
	assertEquals(expectedString, writer.toString());
	}

	public void testCapitalizeOnStringWriter() throws Exception {
	this.verifyCapitalizeOnStringWriter("Oracle", "Oracle");
	this.verifyCapitalizeOnStringWriter("Oracle", "oracle");
	this.verifyCapitalizeOnStringWriter(" ", " ");
	this.verifyCapitalizeOnStringWriter("ORACLE", "ORACLE");
	this.verifyCapitalizeOnStringWriter("", "");
	this.verifyCapitalizeOnStringWriter("A", "a");
	this.verifyCapitalizeOnStringWriter("\u00C9cole", "\u00E9cole"); // e'cole -> E'cole
	}

	private void verifyCapitalizeOnStringWriter(String expected, String string) throws Exception {
	Writer writer = new StringWriter();
	WriterTools.capitalize(writer, string);
	assertEquals(expected, writer.toString());
	}

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

	private void verifyCapitalizeOnCharArray(String expected, char[] string) throws Exception {
	Writer writer = new StringWriter();
	WriterTools.capitalize(writer, string);
	assertEquals(expected, writer.toString());
	}

	public void testUncapitalizeOnStringWriter() throws Exception {
	this.verifyUncapitalizeOnStringWriter("oracle", "Oracle");
	this.verifyUncapitalizeOnStringWriter("oracle", "oracle");
	this.verifyUncapitalizeOnStringWriter(" ", " ");
	this.verifyUncapitalizeOnStringWriter("ORACLE", "ORACLE");
	this.verifyUncapitalizeOnStringWriter("", "");
	this.verifyUncapitalizeOnStringWriter("a", "A");
	this.verifyUncapitalizeOnStringWriter("\u00E9cole", "\u00C9cole"); // E'cole -> e'cole
	}

	private void verifyUncapitalizeOnStringWriter(String expected, String string) throws Exception {
	Writer writer = new StringWriter();
	WriterTools.uncapitalize(writer, string);
	assertEquals(expected, writer.toString());
	}

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

	private void verifyUncapitalizeOnCharArray(String expected, char[] string) throws Exception {
	Writer writer = new StringWriter();
	WriterTools.uncapitalize(writer, string);
	assertEquals(expected, writer.toString());
	}

	public void testConvertToHexString() throws Exception {
	this.verifyConvertToHexString("74657374", "test"); // UTF-8 values
	}

	public void testConvertToHexString_negative() throws Exception {
	this.verifyConvertToHexString(this.getHexCafe(), "caf\u00E9"); // UTF-8 values
	}

	private String getHexCafe() {
	return StringToolsTests.getHexCafe();
	}

	private void verifyConvertToHexString(String expected, String string) throws Exception {
	Writer sb = new StringWriter();
	WriterTools.convertToHexString(sb, string.getBytes());
	assertEquals(expected, sb.toString());
	}

	public void testConvertCamelCaseToAllCaps() throws Exception {
	this.verifyConvertCamelCaseToAllCaps("TEST", "test");
	this.verifyConvertCamelCaseToAllCaps("TEST", "TEST");
	this.verifyConvertCamelCaseToAllCaps("TEST_TEST", "testTest");
	this.verifyConvertCamelCaseToAllCaps("TEST_TEST", "TestTest");
	this.verifyConvertCamelCaseToAllCaps("TEST_TEST_TEST", "testTESTTest");
	this.verifyConvertCamelCaseToAllCaps("TEST_TEST_TEST", "TestTESTTest");
	this.verifyConvertCamelCaseToAllCaps("TEST_TEST_TEST_T", "TestTESTTestT");
	}

	private void verifyConvertCamelCaseToAllCaps(String expected, String string) throws Exception {
	Writer writer = new StringWriter();
	WriterTools.convertCamelCaseToAllCaps(writer, string);
	assertEquals(expected, writer.toString());
	}

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

	private void verifyConvertCamelCaseToAllCapsMaxLength(String expected, String string, int max) throws Exception {
	Writer writer = new StringWriter();
	WriterTools.convertCamelCaseToAllCaps(writer, string, max);
	assertEquals(expected, writer.toString());
	}

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

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

	private void verifyConvertUnderscoresToCamelCase(String expected, String string, boolean capitalizeFirstLetter) throws Exception {
	Writer writer = new StringWriter();
	WriterTools.convertAllCapsToCamelCase(writer, string, capitalizeFirstLetter);
	assertEquals(expected, writer.toString());
	}

	public void testUndelimit() throws Exception {
	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) throws Exception {
	Writer writer = new StringWriter();
	WriterTools.undelimit(writer, s);
	assertEquals(expected, writer.toString());

	writer = new StringWriter();
	WriterTools.undelimit(writer, s.toCharArray());
	assertEquals(expected, writer.toString());
	}

	public void testUndelimitCount() throws Exception {
	this.verifyUndelimitCount("\"foo\"", 2, "o");
	this.verifyUndelimitCount("\"\"\"\"", 2, "");
	this.verifyUndelimitCount("XXfooXX", 2, "foo");
	}

	private void verifyUndelimitCount(String s, int count, String expected) throws Exception {
	Writer writer = new StringWriter();
	WriterTools.undelimit(writer, s, count);
	assertEquals(expected, writer.toString());

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

	public void testConvertToJavaStringLiteral() throws Exception {
	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) throws Exception {
	Writer writer = new StringWriter();
	WriterTools.convertToJavaStringLiteral(writer, s);
	assertEquals(expected, writer.toString());

	writer = new StringWriter();
	WriterTools.convertToJavaStringLiteral(writer, s.toCharArray());
	assertEquals(expected, writer.toString());
	}

	public void testConvertToJavaStringLiteralContent() throws Exception {
	this.verifyConvertToJavaStringLiteralContent("", "");
	this.verifyConvertToJavaStringLiteralContent("\"\"", "\\\"\\\"");
	this.verifyConvertToJavaStringLiteralContent("'foo'", "'foo'");
	this.verifyConvertToJavaStringLiteralContent("foo\bbar", "foo\\bbar");
	this.verifyConvertToJavaStringLiteralContent("foo\n\tbar", "foo\\n\\tbar");
	this.verifyConvertToJavaStringLiteralContent("foo\"bar", "foo\\\"bar");
	this.verifyConvertToJavaStringLiteralContent("foo\\bar", "foo\\\\bar");
	}

	private void verifyConvertToJavaStringLiteralContent(String s, String expected) throws Exception {
	Writer writer = new StringWriter();
	WriterTools.convertToJavaStringLiteralContent(writer, s);
	assertEquals(expected, writer.toString());

	writer = new StringWriter();
	WriterTools.convertToJavaStringLiteralContent(writer, s.toCharArray());
	assertEquals(expected, writer.toString());
	}
	}