stringstest.java

一个自然语言处理的Java开源工具包。LingPipe目前已有很丰富的功能

                                         ","));
        assertEquals("abc",
                     Strings.concatenate(new Object[] { "a", "b", "c" },
                                         ""));
        assertEquals("",Strings.concatenate(new Object[] { }, " "));
    }

    public void testConcatenateObjectArrayStartSpacer() {
        assertEquals("a,b",
                     Strings.concatenate(new Object[] { "a", "b" },
                                         0, ","));
        assertEquals("abc",
                     Strings.concatenate(new Object[] { "e", "a", "b", "c" },
                                         1, ""));
        assertEquals("",Strings.concatenate(new Object[] { },
                                            15, " "));
    }

    public void testConcatenateObjectArrayStartEndSpacer() {
        assertEquals("a,b",
                     Strings.concatenate(new Object[] { "a", "b" },
                                         0, 2, ","));
        assertEquals("abc",
                     Strings.concatenate(new Object[] { "e", "a", "b",
                                                        "c", "f" },
                                         1, 4, ""));
    }

    public void testIndent() {
        StringBuffer sb = new StringBuffer();
        Strings.indent(sb,3);
        assertEquals(sb.toString(),"\n   ");
        sb = new StringBuffer();
        Strings.indent(sb,0);
        assertEquals(sb.toString(),"\n");
    }

    public void testFit() {
        assertEquals("",Strings.fit("",0));
        assertEquals("abc ",Strings.fit("abc",4));
        assertEquals("abc",Strings.fit("abcd",3));
    }

    public void testPadding() {
        assertEquals("",Strings.padding(0));
        assertEquals("  ",Strings.padding(2));
    }

    public void testPaddingSB() {
        StringBuffer sb = new StringBuffer();
        Strings.padding(sb,0);
        assertEquals("",sb.toString());
        sb = new StringBuffer();
        Strings.padding(sb,2);
        assertEquals("  ",sb.toString());
    }

    public void testFunctionArgs() {
        assertEquals("a()",Strings.functionArgs("a",new Object[] { }));
        assertEquals("a(1)",
                     Strings.functionArgs("a",
                                          new Object[] { new Integer(1) }));
        assertEquals("a(1,b)",
                     Strings.functionArgs("a",
                                          new Object[] { new Integer(1),
                                                         "b" }));
    }

    public void testArgsList() {
        assertEquals("()",Strings.functionArgsList(new Object[] { }));
        assertEquals("(a)", Strings.functionArgsList(new Object[] { "a" }));
        assertEquals("(a,b)", Strings.functionArgsList(new Object[] { "a",
                                                                      "b" }));
    }

    public void testTitleCase() {
        assertEquals("",Strings.titleCase(""));
        assertEquals("A",Strings.titleCase("a"));
        assertEquals("1ab",Strings.titleCase("1ab"));
        assertEquals("Abc",Strings.titleCase("abc"));
    }

    public void testConstants() {
        assertEquals(160,Strings.NBSP_CHAR);
        assertEquals('\n',Strings.NEWLINE_CHAR);
        assertEquals(' ',Strings.DEFAULT_SEPARATOR_CHAR);
        assertEquals(" ",Strings.DEFAULT_SEPARATOR_STRING);

    }

    public void testSplit() {
        assertEqualsArray(new String[] { "" },
                          Strings.split("",' '));

        assertEqualsArray(new String[] { "a" },
                          Strings.split("a",' '));

        assertEqualsArray(new String[] { "a", "" },
                          Strings.split("a ",' '));

        assertEqualsArray(new String[] { "", "a" },
                          Strings.split(" a",' '));

        assertEqualsArray(new String[] { "", "a", "" },
                          Strings.split(" a ",' '));

        assertEqualsArray(new String[] { "", "aa", "" },
                          Strings.split(" aa ",' '));
        assertEqualsArray(new String[] { "a", "b" },
                          Strings.split("a b",' '));
        assertEqualsArray(new String[] { "a", "b", "c" },
                          Strings.split("a b c",' '));

        assertEqualsArray(new String[] { "aaa" },
                          Strings.split("aaa",' '));
        assertEqualsArray(new String[] { "aaa", "bb" },
                          Strings.split("aaa bb",' '));
        assertEqualsArray(new String[] { "aaa", "bb", "c" },
                          Strings.split("aaa bb c",' '));

    }


    public void testArrayIO() throws IOException {
        assertArrayIO(new String[] { });
        assertArrayIO(new String[] { "a" });
        assertArrayIO(new String[] { "a", "bcd", "efgh" });
    }

    private void assertArrayIO(String[] testCase) throws IOException {
        ByteArrayOutputStream bytesOut = new ByteArrayOutputStream();
        DataOutputStream dataOut = new DataOutputStream(bytesOut);
        Strings.writeArrayTo(dataOut,testCase);
        byte[] bytes = bytesOut.toByteArray();
        ByteArrayInputStream bytesIn = new ByteArrayInputStream(bytes);
        DataInputStream dataIn = new DataInputStream(bytesIn);
        String[] roundTripResult = Strings.readArrayFrom(dataIn);
        assertEqualsArray(testCase,roundTripResult);
    }

    public void testBytesToHex() {
        assertEquals("",Strings.bytesToHex(new byte[] { }));
        assertEquals("00",Strings.bytesToHex(new byte[] { (byte)0 }));
        assertEquals("0000",Strings.bytesToHex(new byte[] { (byte)0, (byte)0 }));
        assertEquals("ff0f",Strings.bytesToHex(new byte[] { (byte)-1, (byte)15 }));
    }

    public void testByteToHex() {
        assertEquals("ff",Strings.byteToHex((byte)-1));
        assertEquals("0f",Strings.byteToHex((byte)15));
    }

    public void testMsToString() {
        assertEquals(":00",Strings.msToString(0));
        assertEquals(":00",Strings.msToString(999));
        assertEquals(":01",Strings.msToString(1001));
        assertEquals(":32",Strings.msToString(32000));
        assertEquals("1:01",Strings.msToString(61000));
        assertEquals("3:12:03",Strings.msToString((60*60*3 + 60*12 + 3)*1000));
        assertEquals("33:00:00",Strings.msToString((60*60*33)*1000));
    }

    public void testDecimalFormat() {
        assertEquals("2,798.39",Strings.decimalFormat(2798.389,"#,##0.00",8));
        assertEquals(" 2,798.39",Strings.decimalFormat(2798.389,"#,##0.00",9));
        assertEquals("2798.39",Strings.decimalFormat(2798.389,"#0.00",7));
        assertEquals("  2798.39",Strings.decimalFormat(2798.389,"#0.00",9));
        assertEquals("2,798.39",Strings.decimalFormat(2798.389,"#,###.00",8));
        assertEquals(" 2798.39",Strings.decimalFormat(2798.389,"#.00",8));

        assertEquals(" .39",Strings.decimalFormat(0.39,"#.00",4));
        assertEquals("0.39",Strings.decimalFormat(0.39,"#0.00",4));
        assertEquals(" .39",Strings.decimalFormat(0.39,"#,###.00",4));
        assertEquals("0.39",Strings.decimalFormat(0.39,"#,##0.00",4));

        assertEquals("-0.39",Strings.decimalFormat(-0.39,"#,##0.00",5));

        assertEquals("???",Strings.decimalFormat(127.9,"#,##0.00",3));

        try {
            Strings.decimalFormat(1,"#,0,!",4);
            fail();
        } catch (IllegalArgumentException e) {
            succeed();
        }

        try {
            Strings.decimalFormat(1,"#,##0",-2);
            fail();
        } catch (IllegalArgumentException e) {
            succeed();
        }
    }

    public void testNormalizeWhitespace() {
        assertWhitespaceNormalized("abc","abc");
        assertWhitespaceNormalized("abc de fg"," abc de  \t fg\n\n");
        assertWhitespaceNormalized("a b"," a\tb\n");
        assertWhitespaceNormalized("a b","a\t\t\t b");
        assertWhitespaceNormalized("","");
        assertWhitespaceNormalized(""," ");
    }

    private void assertWhitespaceNormalized(String expected, String input) {
        StringBuffer sb = new StringBuffer();
        Strings.normalizeWhitespace(input,sb);
        assertEquals(expected,sb.toString());
    }

    public void testEqualsCharSeqs() {
        StringBuffer sb1 = new StringBuffer();
        StringBuffer sb2 = new StringBuffer();
        assertTrue(Strings.equalCharSequence(sb1,sb2));
        sb1.append("abc");
        assertFalse(Strings.equalCharSequence(sb1,sb2));
        assertTrue(Strings.equalCharSequence("abc",sb1));
    }

}