Add unit tests to com.taobao.arthas.core.util.StringUtils (#638)

2024-04-21 10:21:39 +00:00 · 2019-04-17 15:58:43 +08:00
parent bfc7eb8602
commit f5f2b53e15
1 changed files with 395 additions and 1 deletions
@@ -1,12 +1,21 @@
 package com.taobao.arthas.core.util;

 import org.junit.Assert;
+import org.junit.rules.ExpectedException;
+import org.junit.Rule;
 import org.junit.Test;

+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.TreeMap;
+import java.util.TreeSet;
+import java.util.Properties;
 /**
 * @author bohrqiu 2018-09-21 01:01
+ * @author paulkennethkent 2019-04-08 10:29
 */
 public class StringUtilsTest {
+    @Rule public final ExpectedException thrown = ExpectedException.none();

    @Test
    public void testHumanReadableByteCount() {
@@ -18,4 +27,389 @@ public class StringUtilsTest {
        Assert.assertEquals(StringUtils.humanReadableByteCount(1024L * 1024 * 1024 * 1024L), "1.00 TiB");
        Assert.assertEquals(StringUtils.humanReadableByteCount(1024L * 1024 * 1024 * 1024 * 1024), "1.00 PiB");
    }
-}
+
+    @Test
+    public void testCause() {
+        Assert.assertNull(StringUtils.cause(new Throwable(null, null)));
+
+        final Throwable t2 = new Throwable("error message", new Throwable("error message", null));
+        Assert.assertEquals(t2.getMessage(), StringUtils.cause(t2));
+    }
+
+    @Test
+    public void testCommaDelimitedListToSet() {
+        TreeSet set = new TreeSet();
+        set.add("foo");
+        Assert.assertEquals(set, StringUtils.commaDelimitedListToSet("foo"));
+    }
+
+    @Test
+    public void testCommaDelimitedListToStringArray() {
+        Assert.assertArrayEquals(new String[] {}, StringUtils.commaDelimitedListToStringArray(null));
+        Assert.assertArrayEquals(new String[] {}, StringUtils.commaDelimitedListToStringArray(""));
+        Assert.assertArrayEquals(new String[] {"/////"}, StringUtils.commaDelimitedListToStringArray("/////"));
+        Assert.assertArrayEquals(new String[] {"foo", "bar", "baz"},
+            StringUtils.commaDelimitedListToStringArray("foo,bar,baz"));
+    }
+
+    @Test
+    public void testContainsWhitespaceInputNotNullOutputTrue() {
+        Assert.assertTrue(StringUtils.containsWhitespace("foo  "));
+        Assert.assertTrue(StringUtils.containsWhitespace(" "));
+        Assert.assertFalse(StringUtils.containsWhitespace("!"));
+        Assert.assertFalse(StringUtils.containsWhitespace(""));
+        Assert.assertFalse(StringUtils.containsWhitespace(null));
+    }
+
+    @Test
+    public void testCountOccurrencesOf() {
+        Assert.assertEquals(0, StringUtils.countOccurrencesOf("44444444", "$$$$$$$$"));
+        Assert.assertEquals(0, StringUtils.countOccurrencesOf("$", ""));
+        Assert.assertEquals(0, StringUtils.countOccurrencesOf("", ""));
+        Assert.assertEquals(1, StringUtils.countOccurrencesOf(";;;;;;;:::", ";;;;;;;:"));
+        Assert.assertEquals(3, StringUtils.countOccurrencesOf("foofoofoo", "foo"));
+    }
+
+    @Test
+    public void testDeleteAny() {
+        Assert.assertEquals("", StringUtils.deleteAny("\"", "\"!!!!!!!! "));
+        Assert.assertEquals("\"", StringUtils.deleteAny("\"", "$ 00000000"));
+        Assert.assertEquals("!", StringUtils.deleteAny("!", ""));
+        Assert.assertEquals("", StringUtils.deleteAny("", ""));
+        Assert.assertEquals("barbar", StringUtils.deleteAny("foobarfoobar", "foo"));
+    }
+
+    @Test
+    public void testDelete() {
+        Assert.assertEquals("0", StringUtils.delete("0", ""));
+        Assert.assertEquals("foo", StringUtils.delete("foobar", "bar"));
+    }
+
+    @Test
+    public void testDelimitedListToStringArray() {
+        Assert.assertArrayEquals(new String[] {},
+            StringUtils.delimitedListToStringArray("", ">", ""));
+        Assert.assertArrayEquals(new String[] {"r662"},
+            StringUtils.delimitedListToStringArray("r662", ">>>>", ""));
+        Assert.assertArrayEquals(new String[] {},
+            StringUtils.delimitedListToStringArray("", "", ""));
+        Assert.assertArrayEquals(new String[] {"foo", "br", "bz"},
+            StringUtils.delimitedListToStringArray("foo>bar>baz", ">", "a"));
+    }
+
+    @Test
+    public void testDelimitedListToStringArray2() {
+        Assert.assertArrayEquals(new String[] {}, StringUtils.delimitedListToStringArray(null, ""));
+        Assert.assertArrayEquals(new String[] {"{}~~~~~~"},
+            StringUtils.delimitedListToStringArray("{}~~~~~~", null));
+        Assert.assertArrayEquals(new String[] {"{"}, StringUtils.delimitedListToStringArray("{", ""));
+        Assert.assertArrayEquals(new String[] {}, StringUtils.delimitedListToStringArray("", "????"));
+        Assert.assertArrayEquals(new String[] {"V777VVVVV"},
+            StringUtils.delimitedListToStringArray("V777VVVVV", "77777"));
+        Assert.assertArrayEquals(new String[] {}, StringUtils.delimitedListToStringArray("", ""));
+        Assert.assertArrayEquals(new String[] {"foo", "bar", "baz"},
+            StringUtils.delimitedListToStringArray("foo-bar-baz", "-"));
+    }
+
+    @Test
+    public void testEndsWithIgnoreCase() {
+        Assert.assertFalse(StringUtils.endsWithIgnoreCase(null, ""));
+        Assert.assertFalse(StringUtils.endsWithIgnoreCase("QPPQPPP[", "\'g\'&&\'&A&"));
+        Assert.assertTrue(StringUtils.endsWithIgnoreCase("FFFFFFFFF\'", "f\'"));
+        Assert.assertTrue(StringUtils.endsWithIgnoreCase("&&&&&&&&&\'", "&&&&&\'"));
+    }
+
+    @Test
+    public void testHasLength() {
+        Assert.assertTrue(StringUtils.hasLength("        "));
+        Assert.assertTrue(StringUtils.hasLength("AAAAAAAA"));
+        Assert.assertFalse(StringUtils.hasLength(""));
+        Assert.assertFalse(StringUtils.hasLength(null));
+    }
+
+    @Test
+    public void testHasText() {
+        Assert.assertTrue(StringUtils.hasText(" !"));
+        Assert.assertTrue(StringUtils.hasText("!"));
+        Assert.assertFalse(StringUtils.hasText(" "));
+        Assert.assertFalse(StringUtils.hasText(""));
+    }
+
+    @Test
+    public void testIsBlank() {
+        Assert.assertTrue(StringUtils.isBlank(""));
+        Assert.assertTrue(StringUtils.isBlank(" "));
+        Assert.assertFalse(StringUtils.isBlank(" (!!!!!!!!"));
+    }
+
+    @Test
+    public void testIsEmpty() {
+        Assert.assertFalse(StringUtils.isEmpty(-2147483647));
+        Assert.assertFalse(StringUtils.isEmpty("foo"));
+        Assert.assertTrue(StringUtils.isEmpty(""));
+    }
+
+    @Test
+    public void testJoin() {
+        Assert.assertEquals("7234", StringUtils.join(new Object[] {7, 234}, null));
+        Assert.assertEquals("11", StringUtils.join(new Object[] {11}, null));
+        Assert.assertEquals("", StringUtils.join(new Object[] {}, null));
+        Assert.assertEquals("", StringUtils.join(new Object[] {}, "HH"));
+        Assert.assertEquals("foobarbaz", StringUtils.join(new Object[] {"foo", "bar", "baz"}, ""));
+    }
+
+    @Test
+    public void testLength() {
+        Assert.assertEquals(0, StringUtils.length(null));
+        Assert.assertEquals(0, StringUtils.length(""));
+        Assert.assertEquals(3, StringUtils.length("boo"));
+    }
+
+    @Test
+    public void testNormalizeClassName() {
+        Assert.assertEquals("", StringUtils.normalizeClassName(""));
+        Assert.assertEquals(".", StringUtils.normalizeClassName("/"));
+        Assert.assertEquals("foo.bar.Baz", StringUtils.normalizeClassName("foo/bar/Baz"));
+        Assert.assertEquals("foo.bar.Baz", StringUtils.normalizeClassName("foo.bar.Baz"));
+    }
+
+    @Test
+    public void testObjectToString() {
+        Assert.assertEquals("1", StringUtils.objectToString(1));
+        Assert.assertEquals("", StringUtils.objectToString(null));
+        Assert.assertEquals("{}", StringUtils.objectToString(new TreeMap()));
+    }
+
+    @Test
+    public void testQuoteIfString() {
+        Assert.assertEquals("\'foo\'", StringUtils.quoteIfString("foo"));
+        Assert.assertEquals(1, StringUtils.quoteIfString(1));
+    }
+
+    @Test
+    public void testQuote() {
+        Assert.assertEquals("\'!\'", StringUtils.quote("!"));
+        Assert.assertEquals("\'1234\'", StringUtils.quote("1234"));
+    }
+
+    @Test
+    public void testRepeat() {
+        Assert.assertNull(StringUtils.repeat(null, -1635778558));
+        Assert.assertEquals("", StringUtils.repeat("", 3));
+        Assert.assertEquals("\u0000\u0000", StringUtils.repeat("\u0000", 2));
+        Assert.assertEquals("\u0000\u0000\u0000\u0000", StringUtils.repeat("\u0000\u0000", 2));
+        Assert.assertEquals("", StringUtils.repeat("foo", 0));
+        Assert.assertEquals("foo", StringUtils.repeat("foo", 1));
+        Assert.assertEquals("foofoofoofoo", StringUtils.repeat("foo", 4));
+
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < 8194; i++)
+            sb.append('c');
+        Assert.assertEquals(sb.toString(), StringUtils.repeat('c', 8194));
+
+        thrown.expect(NegativeArraySizeException.class);
+        StringUtils.repeat("\uffff\u2aa0", 1073742337);
+    }
+
+    @Test
+    public void testReplace() {
+        Assert.assertEquals(" ", StringUtils.replace(" ", "", "    "));
+        Assert.assertEquals("", StringUtils.replace("", "", "    "));
+        Assert.assertEquals("baz", StringUtils.replace("bar", "r", "z"));
+    }
+
+    @Test
+    public void testSplitArrayElementsIntoProperties() {
+        final String[] array = {};
+        Assert.assertNull(StringUtils.splitArrayElementsIntoProperties(array, "_", "DEE"));
+
+        final String[] array2 = {"foo=1", "bar=2"};
+        final Properties prop = new Properties();
+        prop.setProperty("foo", "1");
+        prop.setProperty("bar", "2");
+        Assert.assertEquals(prop, StringUtils.splitArrayElementsIntoProperties(array2, "=", ""));
+
+        final String[] array3 = {"    foo=1   ", "   bar=2    "};
+        final Properties prop2 = new Properties();
+        prop2.setProperty("foo", "1");
+        prop2.setProperty("bar", "2");
+        Assert.assertEquals(prop2, StringUtils.splitArrayElementsIntoProperties(array3, "=", " "));
+    }
+
+    @Test
+    public void testSplit() {
+        Assert.assertNull(StringUtils.split("AAAAAAA@@", "AAAAAAAA"));
+        Assert.assertNull(StringUtils.split("@", ""));
+        Assert.assertNull(StringUtils.split("", "AAAAAAAA"));
+        Assert.assertArrayEquals(new String[] {"", ""}, StringUtils.split("A", "A"));
+        Assert.assertArrayEquals(new String[] {"foo", "foo"}, StringUtils.split("foo,foo", ","));
+    }
+
+    @Test
+    public void testStartsWith() {
+        Assert.assertFalse(StringUtils.startsWithIgnoreCase(null, ""));
+        Assert.assertFalse(StringUtils.startsWithIgnoreCase("LHNCC", "TTsVV"));
+        Assert.assertFalse(StringUtils.startsWithIgnoreCase("", "TTTT"));
+        Assert.assertTrue(StringUtils.startsWithIgnoreCase("Foo", "f"));
+    }
+
+    @Test
+    public void testStripEnd() {
+        Assert.assertEquals("foo", StringUtils.stripEnd("foo!", "!"));
+        Assert.assertEquals("  foo", StringUtils.stripEnd("  foo  ", "  "));
+        Assert.assertEquals("!", StringUtils.stripEnd("!", ""));
+        Assert.assertEquals("#", StringUtils.stripEnd("# ", null));
+        Assert.assertEquals("", StringUtils.stripEnd("", "!!"));
+        Assert.assertEquals("1234", StringUtils.stripEnd("1234.0", ".0"));
+    }
+
+    @Test
+    public void testSubstringAfter() {
+        Assert.assertEquals("", StringUtils.substringAfter("foo", null));
+        Assert.assertEquals("!!", StringUtils.substringAfter("!!", ""));
+        Assert.assertEquals("", StringUtils.substringAfter("", ""));
+        Assert.assertEquals("bar", StringUtils.substringAfter("foo=bar", "="));
+    }
+
+    @Test
+    public void testSubstringAfterLast() {
+        Assert.assertEquals("bar", StringUtils.substringAfterLast("foo-bar", "-"));
+        Assert.assertEquals("6", StringUtils.substringAfterLast("123456", "12345"));
+        Assert.assertEquals("", StringUtils.substringAfterLast("foo", "foo"));
+        Assert.assertEquals("", StringUtils.substringAfterLast("foo", ""));
+        Assert.assertEquals("", StringUtils.substringAfterLast("", ""));
+    }
+
+    @Test
+    public void testSubstringBefore() {
+        Assert.assertNull(StringUtils.substringBefore(null, ""));
+        Assert.assertEquals("foo", StringUtils.substringBefore("foo", "-"));
+        Assert.assertEquals("", StringUtils.substringBefore("foo", "foo"));
+        Assert.assertEquals("", StringUtils.substringBefore("?", ""));
+        Assert.assertEquals("foo", StringUtils.substringBefore("foo, bar", ","));
+    }
+
+    @Test
+    public void testSubstringBeforeLast() {
+        Assert.assertEquals("foo", StringUtils.substringBeforeLast("foo", ","));
+        Assert.assertEquals("", StringUtils.substringBeforeLast("foo", "foo"));
+        Assert.assertEquals("", StringUtils.substringBeforeLast("", ","));
+        Assert.assertEquals("foo,bar", StringUtils.substringBeforeLast("foo,bar,baz", ","));
+    }
+
+    @Test
+    public void testSubstringMatch() {
+        Assert.assertFalse(StringUtils.substringMatch("foo", 524290, "o"));
+        Assert.assertFalse(StringUtils.substringMatch("   foo", 2, "@"));
+        Assert.assertTrue(StringUtils.substringMatch("{{", 1, "{"));
+        Assert.assertTrue(StringUtils.substringMatch("foo", 524290, ""));
+        Assert.assertTrue(StringUtils.substringMatch("foobarbaz", 3, "bar"));
+    }
+
+    @Test
+    public void testTokenizeToStringArray() {
+        Assert.assertNull(StringUtils.tokenizeToStringArray(null, "?", true, false));
+        Assert.assertArrayEquals(new String[] {},
+            StringUtils.tokenizeToStringArray("", "\"\"", false, false));
+        Assert.assertArrayEquals(new String[] {"bar", "baz", "foo  "},
+            StringUtils.tokenizeToStringArray("bar,baz,foo  ,,", ",", false, true));
+        Assert.assertArrayEquals(new String[] {"bar", "baz", "foo  "},
+            StringUtils.tokenizeToStringArray("bar,baz,foo  ,,", ",", false, false));
+
+        Assert.assertArrayEquals(new String[] {"bar", "baz", "foo"},
+            StringUtils.tokenizeToStringArray("bar,baz,foo  ,,", ","));
+    }
+
+    @Test
+    public void testToStringArray() {
+        final Collection<String> collection = null;
+        final ArrayList<String> arrayList = new ArrayList<String>();
+        final ArrayList<String> arrayList2 = new ArrayList<String>();
+        arrayList2.add("foo");
+
+        Assert.assertNull(StringUtils.toStringArray(collection));
+        Assert.assertArrayEquals(new String[] {}, StringUtils.toStringArray(arrayList));
+        Assert.assertArrayEquals(new String[] {"foo"}, StringUtils.toStringArray(arrayList2));
+    }
+
+    @Test
+    public void testTrimAllWhitespace() {
+        Assert.assertEquals("", StringUtils.trimAllWhitespace(" "));
+        Assert.assertEquals("", StringUtils.trimAllWhitespace(""));
+        Assert.assertEquals("foo", StringUtils.trimAllWhitespace("foo"));
+        Assert.assertEquals("foo", StringUtils.trimAllWhitespace("  foo  "));
+    }
+
+    @Test
+    public void testTrimLeadingCharacter() {
+        Assert.assertEquals("", StringUtils.trimLeadingCharacter("", 'a'));
+        Assert.assertEquals("foo", StringUtils.trimLeadingCharacter("foo", 'a'));
+        Assert.assertEquals("", StringUtils.trimLeadingCharacter("a", 'a'));
+        Assert.assertEquals("foo", StringUtils.trimLeadingCharacter("afoo", 'a'));
+    }
+
+    @Test
+    public void testTrimLeadingWhitespace() {
+        Assert.assertEquals("", StringUtils.trimLeadingWhitespace(""));
+        Assert.assertEquals("", StringUtils.trimLeadingWhitespace(" "));
+        Assert.assertEquals("!", StringUtils.trimLeadingWhitespace("!"));
+        Assert.assertEquals("foo  ", StringUtils.trimLeadingWhitespace("  foo  "));
+    }
+
+    @Test
+    public void testTrimTrailingCharacter() {
+        Assert.assertEquals("foo", StringUtils.trimTrailingCharacter("foo!", '!'));
+        Assert.assertEquals("", StringUtils.trimTrailingCharacter("", '!'));
+        Assert.assertEquals("", StringUtils.trimTrailingCharacter("!", '!'));
+    }
+
+    @Test
+    public void testTrimTrailingWhitespace() {
+        Assert.assertEquals("", StringUtils.trimTrailingWhitespace(" "));
+        Assert.assertEquals("", StringUtils.trimTrailingWhitespace(""));
+        Assert.assertEquals("  foo", StringUtils.trimTrailingWhitespace("  foo   "));
+    }
+
+    @Test
+    public void testTrimWhitespace() {
+        Assert.assertEquals("\u6d7c\u1280", StringUtils.trimWhitespace(" \u6d7c\u1280\u1680"));
+        Assert.assertEquals("", StringUtils.trimWhitespace(" "));
+        Assert.assertEquals("(", StringUtils.trimWhitespace("("));
+        Assert.assertEquals("", StringUtils.trimWhitespace(""));
+        Assert.assertEquals("foo foo", StringUtils.trimWhitespace(" foo foo "));
+    }
+
+    @Test
+    public void testUncapitalize() {
+        Assert.assertEquals("a", StringUtils.uncapitalize("A"));
+        Assert.assertEquals("a", StringUtils.uncapitalize("a"));
+        Assert.assertEquals("", StringUtils.uncapitalize(""));
+    }
+
+    @Test
+    public void testCapitalize() {
+        Assert.assertEquals("A", StringUtils.capitalize("a"));
+        Assert.assertEquals("A", StringUtils.capitalize("A"));
+        Assert.assertEquals("", StringUtils.capitalize(""));
+    }
+
+    @Test
+    public void testUnqualify() {
+        Assert.assertEquals("c", StringUtils.unqualify("a.b.c"));
+        Assert.assertEquals("d", StringUtils.unqualify("a!b!c!d", '!'));
+    }
+
+    @Test
+    public void testWrap() {
+        Assert.assertEquals("\n!", StringUtils.wrap("!", 0));
+        Assert.assertEquals("", StringUtils.wrap("", 1));
+        Assert.assertEquals("f\no\no", StringUtils.wrap("foo", 1));
+        Assert.assertEquals("f\n", StringUtils.wrap("f\n", 1));
+        Assert.assertEquals("\u0001\n", StringUtils.wrap("\u0001\n", 3));
+    }
+
+    @Test
+    public void testClassLoaderHash() {
+        Assert.assertEquals("null", StringUtils.classLoaderHash(null));
+    }
+}