stringstest.java

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

/*
 * LingPipe v. 3.5
 * Copyright (C) 2003-2008 Alias-i
 *
 * This program is licensed under the Alias-i Royalty Free License
 * Version 1 WITHOUT ANY WARRANTY, without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the Alias-i
 * Royalty Free License Version 1 for more details.
 *
 * You should have received a copy of the Alias-i Royalty Free License
 * Version 1 along with this program; if not, visit
 * http://alias-i.com/lingpipe/licenses/lingpipe-license-1.txt or contact
 * Alias-i, Inc. at 181 North 11th Street, Suite 401, Brooklyn, NY 11211,
 * [phone].
 */

package com.aliasi.test.unit.util;

import com.aliasi.util.Strings;

import com.aliasi.test.unit.BaseTestCase;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;

import java.nio.CharBuffer;

public class StringsTest extends BaseTestCase {

    public void testSharedPrefixLength() {
        testPref("","",0);
        testPref("a","",0);
        testPref("","a",0);
        testPref("a","a",1);
        testPref("ab","a",1);
        testPref("a","ab",1);
        testPref("abc","abcd",3);
        testPref("abcdefg","abc",3);
        testPref("bcd","cde",0);
    }

    void testPref(String a, String b, int expectedVal) {
        assertEquals(expectedVal,Strings.sharedPrefixLength(a,b));
    }

    public void testHashCode() {
        testHashCode("");
        testHashCode("abc");
        testHashCode("xyz kdkdkpq984yuro8iuz");
    }

    void testHashCode(String input) {
        int expectedHash = input.hashCode();
        assertEquals(expectedHash,Strings.hashCode(input));

        StringBuffer sb = new StringBuffer();
        sb.append(input);
        assertEquals(expectedHash,Strings.hashCode(sb));

        char[] cs = input.toCharArray();
        CharBuffer buf = CharBuffer.wrap(cs);
        assertEquals(expectedHash,Strings.hashCode(buf));
    }

    public void testReverse() {
        assertReverse("","");
        assertReverse("a","a");
        assertReverse("ab","ba");
        assertReverse("abc","cba");
    }

    void assertReverse(String x, String xRev) {
        assertEquals(xRev,Strings.reverse(x));
    }

    public void testUTF8IsSupported() {
        boolean threw = false;
        try {
            new String(new byte[] { (byte)'a' },
                       Strings.UTF8);
        } catch (UnsupportedEncodingException e) {
            threw = true;
        }
        assertFalse(threw);
    }

    public void testAllLetters() {
        assertTrue(Strings.allLetters("abc".toCharArray()));
        assertTrue(Strings.allLetters("".toCharArray()));
        assertFalse(Strings.allLetters("abc1".toCharArray()));
    }

    public void testAllUpperCase() {
        assertTrue(Strings.allUpperCase("ABC".toCharArray()));
        assertTrue(Strings.allUpperCase("".toCharArray()));
        assertFalse(Strings.allUpperCase("ABC1".toCharArray()));
    }

    public void testCapitalized() {
        assertFalse(Strings.capitalized("".toCharArray()));
        assertTrue(Strings.capitalized("Abc".toCharArray()));
        assertFalse(Strings.capitalized("Abc1".toCharArray()));
    }

    public void testContainsDigits() {
        assertTrue(Strings.containsDigits("123".toCharArray()));
        assertFalse(Strings.containsDigits("".toCharArray()));
        assertTrue(Strings.containsDigits("abc1".toCharArray()));
        assertFalse(Strings.containsDigits("abc".toCharArray()));
    }

    public void testContainsLetter() {
        assertTrue(Strings.containsLetter("abc".toCharArray()));
        assertFalse(Strings.containsLetter("".toCharArray()));
        assertTrue(Strings.containsLetter("abc1".toCharArray()));
        assertFalse(Strings.containsLetter("123".toCharArray()));
    }

    public void testAllPunctuation() {
        assertTrue(Strings.allPunctuation(";..?!".toCharArray()));
        assertTrue(Strings.allPunctuation("".toCharArray()));
        assertFalse(Strings.allPunctuation("\".".toCharArray()));
    }

    public void testAllPunctuationString() {
        assertTrue(Strings.allPunctuation(";..?!"));
        assertTrue(Strings.allPunctuation(""));
        assertFalse(Strings.allPunctuation("\"."));
    }

    public void testAllSymbols() {
        assertTrue(Strings.allSymbols(";..?!".toCharArray()));
        assertTrue(Strings.allSymbols("".toCharArray()));
        assertTrue(Strings.allSymbols("\".".toCharArray()));
        assertFalse(Strings.allSymbols("$%^&*abc".toCharArray()));
    }

    public void testSave() {
        String s1 = "";
        String s2 = "abc def";
        assertFullEquals(s1,Strings.save(s1));
        assertFullEquals(s2,Strings.save(s2));
    }

    public void testContainsChar() {
        assertTrue(Strings.containsChar("abc",'a'));
        assertTrue(Strings.containsChar("abc",'b'));
        assertTrue(Strings.containsChar("abc",'c'));
        assertFalse(Strings.containsChar("abc",'d'));
        assertFalse(Strings.containsChar("",'a'));
    }

    public void testAllWhitespace() {
        assertTrue(Strings.allWhitespace(""));
        assertTrue(Strings.allWhitespace(" \n \t"));
        assertFalse(Strings.allWhitespace("  a  "));
    }

    public void testAllWhitespaceSB() {
        assertTrue(Strings.allWhitespace(new StringBuffer("")));
        assertTrue(Strings.allWhitespace(new StringBuffer(" \n \t")));
        assertFalse(Strings.allWhitespace(new StringBuffer("  a  ")));
    }

    public void testAllWhitespaceArray() {
        assertTrue(Strings.allWhitespace("".toCharArray(),0,0));
        assertTrue(Strings.allWhitespace(" \n \t ".toCharArray(),0,3));
        assertTrue(Strings.allWhitespace("     a  ".toCharArray(),1,2));
        assertFalse(Strings.allWhitespace("     a  ".toCharArray(),3,3));
    }


    public void testAllDigits() {
        assertTrue(Strings.allDigits(""));
        assertTrue(Strings.allDigits("123"));
        assertFalse(Strings.allDigits("1.23"));
        assertFalse(Strings.allDigits("1ab"));
    }

    public void testAllDigitsArray() {
        assertTrue(Strings.allDigits("".toCharArray(),0,0));
        assertTrue(Strings.allDigits("123".toCharArray(),0,3));
        assertFalse(Strings.allDigits("1.23".toCharArray(),0,4));
        assertFalse(Strings.allDigits("1ab".toCharArray(),0,3));
    }

    public void testIsWhitespace() {
        assertTrue(Strings.isWhitespace((char)160));
        assertTrue(Strings.isWhitespace(' '));
        assertTrue(Strings.isWhitespace('\n'));
        assertFalse(Strings.isWhitespace('a'));
    }

    public void testIsPunctuation() {
        assertTrue(Strings.isPunctuation('!'));
        assertTrue(Strings.isPunctuation('?'));
        assertTrue(Strings.isPunctuation(';'));
        assertFalse(Strings.isPunctuation('"'));
        assertFalse(Strings.isPunctuation('a'));
    }

    public void testPower() {
        assertEquals("",Strings.power("abc",0));
        assertEquals("",Strings.power("",3));
        assertEquals("aaa",Strings.power("a",3));
    }

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

    public void testConcatenateObjectArraySpacer() {
        assertEquals("a,b",
                     Strings.concatenate(new Object[] { "a", "b" },