stringstest.java

Wicket一个开发Java Web应用程序框架。它使得开发web应用程序变得容易而轻松。 Wicket利用一个POJO data beans组件使得它可以与任何持久层技术相结合。

		assertFalse(Strings.isTrue("fAlSe"));
		assertFalse(Strings.isTrue("0"));

		assertTrue(Strings.isTrue("yes"));
		assertTrue(Strings.isTrue("y"));
		assertTrue(Strings.isTrue("true"));
		assertTrue(Strings.isTrue("1"));
		assertTrue(Strings.isTrue("YeS"));
		assertTrue(Strings.isTrue("Y"));
		assertTrue(Strings.isTrue("tRuE"));
		assertTrue(Strings.isTrue("1"));

		try
		{
			Strings.isTrue("foo");
			fail("Exception expected");
		}
		catch (StringValueConversionException e)
		{
			assertTrue(true);
		}
	}

	/**
	 * Tests the <code>replaceAll</code> method.
	 */
	public void testReplaceAll()
	{
		assertNull(Strings.replaceAll(null, null, null));
		assertNull(Strings.replaceAll(null, "", null));
		assertNull(Strings.replaceAll(null, null, ""));
		assertNull(Strings.replaceAll(null, "", ""));

		assertEquals("", Strings.replaceAll("", null, null));
		assertEquals("", Strings.replaceAll("", "", null));
		assertEquals("", Strings.replaceAll("", null, ""));
		assertEquals("", Strings.replaceAll("", "", ""));
		assertEquals("", Strings.replaceAll("", "", "abc"));
		assertEquals("", Strings.replaceAll("", "abc", "def"));
		assertEquals("", Strings.replaceAll("abc", "abc", "").toString());

		assertEquals("abc", Strings.replaceAll("abc", "", ""));
		assertEquals("abc", Strings.replaceAll("abc", "abc", "abc").toString());
		assertEquals("def", Strings.replaceAll("abc", "abc", "def").toString());
		assertEquals("abc", Strings.replaceAll("abc", "ABC", "").toString());

		assertEquals("abc", Strings.replaceAll("abc", "d", null));
		assertEquals("ab", Strings.replaceAll("abc", "c", null).toString());
		assertEquals("bc", Strings.replaceAll("abc", "a", null).toString());

		assertEquals("aaaa", Strings.replaceAll("aa", "a", "aa").toString());
	}

	/**
	 * Tests the <code>split</code> method.
	 */
	public void testSplit()
	{
		assertEquals(new String[0], Strings.split(null, '.'));
		assertEquals(new String[0], Strings.split("", '.'));
		assertEquals(new String[] { "", "" }, Strings.split(".", '.'));
		assertEquals(new String[] { "a", "" }, Strings.split("a.", '.'));
		assertEquals(new String[] { "a", "b" }, Strings.split("a.b", '.'));
		assertEquals(new String[] { "a", "b", "c" }, Strings.split("a.b.c", '.'));
		assertEquals(new String[] { "a", "b", "c" }, Strings.split("a b c", ' '));
		assertEquals(new String[] { "abc" }, Strings.split("abc", ' '));
	}

	/**
	 * Tests the <code>stripEnding</code> method.
	 */
	public void testStripEnding()
	{
		assertNull(Strings.stripEnding(null, null));
		assertEquals("", Strings.stripEnding("", null));
		assertEquals("", Strings.stripEnding("", ""));
		assertEquals("a", Strings.stripEnding("a", ""));
		assertEquals("", Strings.stripEnding("a", "a"));
		assertEquals("a", Strings.stripEnding("a", "aa"));
		assertEquals("abc", Strings.stripEnding("abc", "ab"));
	}

	/**
	 * Tests the <code>toBoolean</code> method.
	 * 
	 * @throws StringValueConversionException
	 */
	public void testToBoolean() throws StringValueConversionException
	{
		assertEquals(Boolean.FALSE, Strings.toBoolean(null));
		assertEquals(Boolean.FALSE, Strings.toBoolean("off"));
		assertEquals(Boolean.FALSE, Strings.toBoolean("no"));
		assertEquals(Boolean.FALSE, Strings.toBoolean("n"));
		assertEquals(Boolean.FALSE, Strings.toBoolean("false"));
		assertEquals(Boolean.FALSE, Strings.toBoolean("0"));

		assertEquals(Boolean.TRUE, Strings.toBoolean("on"));
		assertEquals(Boolean.TRUE, Strings.toBoolean("yes"));
		assertEquals(Boolean.TRUE, Strings.toBoolean("y"));
		assertEquals(Boolean.TRUE, Strings.toBoolean("true"));
		assertEquals(Boolean.TRUE, Strings.toBoolean("1"));

		try
		{
			Strings.toBoolean("waar");
			fail("Exception expected");
		}
		catch (StringValueConversionException e)
		{
			assertTrue(true);
		}
	}

	/**
	 * Tests the <code>toChar</code> method.
	 * 
	 * @throws StringValueConversionException
	 */
	public void testToChar() throws StringValueConversionException
	{
		assertEquals(' ', Strings.toChar(" "));
		assertEquals('a', Strings.toChar("a"));

		try
		{
			Strings.toChar("");
			fail("Exception expected");
		}
		catch (StringValueConversionException e)
		{
		}
		try
		{
			Strings.toChar(null);
			fail("Exception expected");
		}
		catch (StringValueConversionException e)
		{
		}
		try
		{
			Strings.toChar("aa");
			fail("Exception expected");
		}
		catch (StringValueConversionException e)
		{
		}
	}

	/**
	 * Tests the <code>toMultilineMarkup</code> method.
	 */
	public void testToMultilineMarkup()
	{
		assertNull(Strings.toMultilineMarkup(null));
		assertEquals("<p></p>", Strings.toMultilineMarkup("").toString());
		assertEquals("<p></p><p></p>", Strings.toMultilineMarkup("\n\n").toString());
		assertEquals("<p><br/></p>", Strings.toMultilineMarkup("\n").toString());
		assertEquals("<p>abc</p>", Strings.toMultilineMarkup("abc").toString());
		assertEquals("<p>abc<br/></p>", Strings.toMultilineMarkup("abc\n").toString());
		assertEquals("<p>abc<br/>def</p>", Strings.toMultilineMarkup("abc\ndef").toString());
		assertEquals("<p>abc<br/>def</p>", Strings.toMultilineMarkup("abc\r\ndef").toString());
		assertEquals("<p>abc<br/>def<br/>ghi</p>", Strings.toMultilineMarkup("abc\ndef\nghi")
				.toString());

		assertEquals("<p>abc</p><p>def</p><p>ghi</p>", Strings.toMultilineMarkup(
				"abc\n\ndef\n\nghi").toString());
		assertEquals("<p>abc</p><p>def</p><p>ghi</p>", Strings.toMultilineMarkup(
				"abc\r\n\r\ndef\r\n\r\nghi").toString());
		assertEquals("<p>abc</p><p>def</p><p>ghi</p><p></p>", Strings.toMultilineMarkup(
				"abc\r\n\r\ndef\r\n\r\nghi\n\n").toString());

		assertEquals("<p>\\n</p>", Strings.toMultilineMarkup("\\n").toString());
		assertEquals("<p>a\\nbc</p>", Strings.toMultilineMarkup("a\\nbc").toString());
	}

	/**
	 * Tests the <code>toString</code> method.
	 */
	public void testToString()
	{
		assertNull(Strings.toString((Object)null));
		assertEquals("", Strings.toString(""));

		assertEquals("<Null Throwable>", Strings.toString(null));
		try
		{
			throw new IllegalArgumentException("Foo");
		}
		catch (IllegalArgumentException e)
		{
			final String toString = Strings.toString((Object)e);
			String before = Strings.beforeFirst(toString, '\n').trim();
			assertEquals("Root cause:", before);
		}
	}

	/**
	 * Test the toString(throwable)
	 */
	public void testToStringThrowable()
	{
		NullPointerException np = new NullPointerException("null test");
		WicketRuntimeException wre = new WicketRuntimeException("null test", np);
		String exceptionString = Strings.toString(wre);
		assertTrue(exceptionString.length() > 1);
		assertTrue(exceptionString.indexOf("WicketRuntimeException") != -1);
	}

	/**
	 * Asserts that both string arrays are equal.
	 * 
	 * @param expected
	 *            the expected value
	 * @param actual
	 *            the actual value
	 */
	private void assertEquals(String[] expected, String[] actual)
	{
		if (expected == null)
		{
			assertNull(actual);
		}
		assertEquals(stringValue(expected), stringValue(actual));
	}

	/**
	 * Converts an array of strings to a String. ["a", "b"] becomes: "[a,b]"
	 * 
	 * @param arrayOfStrings
	 *            the array to convert
	 * @return the array as a string.
	 */
	private String stringValue(String[] arrayOfStrings)
	{
		AppendingStringBuffer sb = new AppendingStringBuffer("[");
		String komma = "";
		for (int i = 0; i < arrayOfStrings.length; i++)
		{
			sb.append(komma);
			sb.append(arrayOfStrings[i]);
			komma = ",";
		}
		sb.append("]");
		return sb.toString();
	}
}