Clover Coverage Report
Coverage timestamp: Sat Sep 18 2010 04:09:52 UTC
Overview   Package   File
    FRAMES   NO FRAMES     
220   467   33   10.48
2   319   0.15   21
21     1.57  
1    
 
  StringUtilityTest       Line # 28 220 33 93.8% 0.9382716
 
  (15)
 
1    /* This file is part of the project "Hilbert II" - http://www.qedeq.org
2    *
3    * Copyright 2000-2010, Michael Meyling <mime@qedeq.org>.
4    *
5    * "Hilbert II" is free software; you can redistribute
6    * it and/or modify it under the terms of the GNU General Public
7    * License as published by the Free Software Foundation; either
8    * version 2 of the License, or (at your option) any later version.
9    *
10    * This program is distributed in the hope that it will be useful,
11    * but WITHOUT ANY WARRANTY; without even the implied warranty of
12    * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13    * GNU General Public License for more details.
14    */
15   
16    package org.qedeq.base.utility;
17   
18    import java.io.IOException;
19   
20    import org.qedeq.base.test.QedeqTestCase;
21   
22    /**
23    * Test {@link StringUtility}.
24    *
25    * @version $Revision: 1.1 $
26    * @author Michael Meyling
27    */
 
28    public class StringUtilityTest extends QedeqTestCase {
29   
30    /*
31    * @see TestCase#setUp()
32    */
 
33  15 toggle protected void setUp() throws Exception {
34  15 super.setUp();
35    }
36   
37    /*
38    * @see TestCase#tearDown()
39    */
 
40  15 toggle protected void tearDown() throws Exception {
41  15 super.tearDown();
42    }
43   
44    /**
45    * Test replace(String, String, String).
46    *
47    * @throws Exception
48    */
 
49  1 toggle public void testReplace() throws Exception {
50  1 assertEquals("", StringUtility.replace("", "12345", "89"));
51  1 assertEquals("", StringUtility.replace((String) null, "12345", "89"));
52  1 assertEquals("", StringUtility.replace((String) null, null, null));
53  1 assertEquals("", StringUtility.replace("", null, "89"));
54  1 assertEquals("", StringUtility.replace("", "2", null));
55  1 assertEquals("", StringUtility.replace("", "", null));
56  1 assertEquals("", StringUtility.replace("", "", ""));
57  1 assertEquals("", StringUtility.replace("", null, ""));
58  1 assertEquals("", StringUtility.replace((String) null, "", ""));
59  1 assertEquals("", StringUtility.replace("", "1", "1"));
60  1 assertEquals("", StringUtility.replace("", "12", "12"));
61  1 assertEquals("1", StringUtility.replace("1", "1", "1"));
62  1 assertEquals("12", StringUtility.replace("12", "12", "12"));
63  1 assertEquals("", StringUtility.replace("1", "1", ""));
64  1 assertEquals("", StringUtility.replace("12", "12", ""));
65  1 assertEquals("", StringUtility.replace("1", "1", null));
66  1 assertEquals("", StringUtility.replace("12", "12", null));
67  1 assertEquals("13", StringUtility.replace("12", "2", "3"));
68  1 assertEquals("1", StringUtility.replace("12", "2", null));
69  1 assertEquals("12", StringUtility.replace("12", "", "7"));
70  1 assertEquals("12", StringUtility.replace("12", null, "7"));
71  1 assertEquals("145", StringUtility.replace("12345", "23", null));
72  1 assertEquals("12345", StringUtility.replace("12345", "23", "23"));
73  1 assertEquals("12AA12AA12", StringUtility.replace("12012012", "0", "AA"));
74  1 assertEquals("AA12AA12AA12AA", StringUtility.replace("0120120120", "0", "AA"));
75  1 assertEquals("AA12ABA12AA12AA", StringUtility.replace("012ABA120120", "0", "AA"));
76  1 assertEquals("012ABA120120", StringUtility.replace("012ABA120120", "", "AA"));
77  1 assertEquals("012ABA120120", StringUtility.replace("012ABA120120", null, "AA"));
78  1 assertEquals("012ABA120120", StringUtility.replace("012ABA120120", null, null));
79  1 assertEquals("012ABA120120", StringUtility.replace("012ABA120120", "", "AA"));
80  1 assertEquals("12ABA1212", StringUtility.replace("012ABA120120", "0", null));
81  1 assertEquals("12ABA1212", StringUtility.replace("012ABA120120", "0", ""));
82  1 assertEquals("012ABA120120", StringUtility.replace("012ABA120120", "", ""));
83  1 assertEquals("A3A2A3A2A3A20", StringUtility.replace("0120120120", "01", "A3A"));
84  1 assertEquals("0ABA1200", StringUtility.replace("012ABA120120", "012", "0"));
85  1 assertEquals("012ABA120120", StringUtility.replace("012ABA120120", "", "012"));
86  1 assertEquals("012ABA120120", StringUtility.replace("012ABA120120", null, "012"));
87  1 assertEquals("", StringUtility.replace("012ABA120120", "012ABA120120", ""));
88  1 assertEquals("", StringUtility.replace("012ABA120120", "012ABA120120", null));
89  1 assertEquals("012ABA120120", StringUtility.replace("012ABA120120", "012ABA120120",
90    "012ABA120120"));
91    }
92   
93    /**
94    * Test replace(String, String, String).
95    *
96    * @throws Exception
97    */
 
98  1 toggle public void testReplaceStringBuffer() throws Exception {
99  1 StringBuffer buffer = new StringBuffer();
100  1 doReplace(buffer, "", "", "12345", "89");
101  1 doReplace(buffer, "", "", null, null);
102  1 doReplace(buffer, "", "", null, "89");
103  1 doReplace(buffer, "", "", "2", null);
104  1 doReplace(buffer, "", "", "", null);
105  1 doReplace(buffer, "", "", "", "");
106  1 doReplace(buffer, "", "", "1", "1");
107  1 doReplace(buffer, "", "", "12", "12");
108  1 doReplace(buffer, "1", "1", "1", "1");
109  1 doReplace(buffer, "12", "12", "12", "12");
110  1 doReplace(buffer, "", "1", "1", "");
111  1 doReplace(buffer, "", "12", "12", "");
112  1 doReplace(buffer, "", "1", "1", null);
113  1 doReplace(buffer, "", "12", "12", null);
114  1 doReplace(buffer, "13", "12", "2", "3");
115  1 doReplace(buffer, "1", "12", "2", null);
116  1 doReplace(buffer, "12", "12", "", "7");
117  1 doReplace(buffer, "12", "12", null, "7");
118  1 doReplace(buffer, "145", "12345", "23", null);
119  1 doReplace(buffer, "12345", "12345", "23", "23");
120  1 doReplace(buffer, "12AA12AA12", "12012012", "0", "AA");
121  1 doReplace(buffer, "AA12AA12AA12AA", "0120120120", "0", "AA");
122  1 doReplace(buffer, "AA12ABA12AA12AA", "012ABA120120", "0", "AA");
123  1 doReplace(buffer, "012ABA120120", "012ABA120120", "", "AA");
124  1 doReplace(buffer, "012ABA120120", "012ABA120120", null, "AA");
125  1 doReplace(buffer, "012ABA120120", "012ABA120120", null, null);
126  1 doReplace(buffer, "012ABA120120", "012ABA120120", "", "AA");
127  1 doReplace(buffer, "12ABA1212", "012ABA120120", "0", null);
128  1 doReplace(buffer, "12ABA1212", "012ABA120120", "0", "");
129  1 doReplace(buffer, "012ABA120120", "012ABA120120", "", "");
130  1 doReplace(buffer, "A3A2A3A2A3A20", "0120120120", "01", "A3A");
131  1 doReplace(buffer, "0ABA1200", "012ABA120120", "012", "0");
132  1 doReplace(buffer, "012ABA120120", "012ABA120120", "", "012");
133  1 doReplace(buffer, "012ABA120120", "012ABA120120", null, "012");
134  1 doReplace(buffer, "", "012ABA120120", "012ABA120120", "");
135  1 doReplace(buffer, "", "012ABA120120", "012ABA120120", null);
136  1 doReplace(buffer, "012ABA120120", "012ABA120120", "012ABA120120",
137    "012ABA120120");
138  1 try {
139  1 doReplace(null, "AA12ABA12AA12AA", "012ABA120120", "0", "AA");
140  0 fail("NullPointerException expected");
141    } catch (NullPointerException e) {
142    // expected;
143    }
144    }
145   
 
146  38 toggle private void doReplace(final StringBuffer buffer, final String expected, final String text,
147    final String search, final String replacement) {
148  38 buffer.setLength(0);
149  37 buffer.append(expected);
150  37 StringUtility.replace(buffer, search, replacement);
151  37 assertEquals(expected, buffer.toString());
152    }
153   
154    /**
155    * Test {@link StringUtility#quote(String)}.
156    *
157    * @throws Exception Test failed.
158    */
 
159  1 toggle public void testQuote() throws Exception {
160  1 assertEquals("\"\"", StringUtility.quote(""));
161  1 assertEquals("\"\"\"\"", StringUtility.quote("\""));
162  1 assertEquals("\"a\"", StringUtility.quote("a"));
163  1 assertEquals("\"\"\"a\"\"\"", StringUtility.quote("\"a\""));
164  1 assertEquals("\"b\"\"a\"\"c\"", StringUtility.quote("b\"a\"c"));
165  1 try {
166  1 StringUtility.quote(null);
167  0 fail("NullPointerException expected");
168    } catch (NullPointerException e) {
169    // expected
170    }
171    }
172   
173    /**
174    * Test {@link StringUtility#isLetterDigitString(String)}.
175    *
176    * @throws Exception Test failed.
177    */
 
178  1 toggle public void testIsLetterDigitString() throws Exception {
179  1 assertFalse(StringUtility.isLetterDigitString(""));
180  1 assertTrue(StringUtility.isLetterDigitString("a"));
181  1 assertFalse(StringUtility.isLetterDigitString("1a"));
182  1 assertTrue(StringUtility.isLetterDigitString("a1"));
183  1 assertFalse(StringUtility.isLetterDigitString(" 1"));
184  1 assertFalse(StringUtility.isLetterDigitString("a 1"));
185  1 assertTrue(StringUtility.isLetterDigitString("AllOneTwo3"));
186  1 assertTrue(StringUtility.isLetterDigitString("Z111111999999999"));
187  1 assertFalse(StringUtility.isLetterDigitString("$A111111999999999"));
188  1 try {
189  1 StringUtility.isLetterDigitString(null);
190  0 fail("NullPointerException expected");
191    } catch (NullPointerException e) {
192    // expected
193    }
194    }
195   
196    /**
197    * Test {@link StringUtility#getSpaces(int))}.
198    *
199    * @throws Exception Test failed.
200    */
 
201  1 toggle public void testGetSpaces() throws Exception {
202  1 eq("", StringUtility.getSpaces(0));
203  1 eq(" ", StringUtility.getSpaces(1));
204  1 eq(" ", StringUtility.getSpaces(2));
205  1 eq(" ", StringUtility.getSpaces(3));
206  1 eq(" ", StringUtility.getSpaces(4));
207  1 eq(" ", StringUtility.getSpaces(5));
208  1 eq(" ", StringUtility.getSpaces(6));
209  1 eq(" ", StringUtility.getSpaces(7));
210  1 eq(" ", StringUtility.getSpaces(8));
211  1 eq(" ", StringUtility.getSpaces(9));
212  1 eq(" ",
213    StringUtility.getSpaces(80));
214  1 eq("", StringUtility.getSpaces(-1));
215  1 eq("", StringUtility.getSpaces(-999999));
216    }
217   
 
218  13 toggle public void eq(final String expected, final StringBuffer spaces) throws Exception {
219  13 assertEquals(expected.length(), spaces.length());
220  13 assertEquals(expected, spaces.toString());
221    }
222   
223    /**
224    * Test {@link StringUtility#getClassName(Class)}.
225    *
226    * @throws Exception Test failed.
227    */
 
228  1 toggle public void testGetClassName() throws Exception {
229  1 assertEquals("IOException", StringUtility.getClassName(IOException.class));
230    }
231   
232    /**
233    * Test {@link StringUtility#deleteLineLeadingWhitespace(StringBuffer)}.
234    *
235    * @throws Exception Test failed.
236    */
 
237  1 toggle public void testDeleteLineLeadingWhitespace() throws Exception {
238  1 eq("", "");
239  1 eq("A", "A");
240  1 eq(" A", "A");
241  1 eq("\tA", "A");
242  1 String muffin1 = " Do you know the muffin man,\n"
243    + " The muffin man, the muffin man,\n"
244    + " Do you know the muffin man,\n"
245    + " Who lives on Drury Lane?\n";
246  1 String muffin2 = "Do you know the muffin man,\n"
247    + "The muffin man, the muffin man,\n"
248    + "Do you know the muffin man,\n"
249    + "Who lives on Drury Lane?\n";
250  1 String muffin3 = "Do you know the muffin man,\n"
251    + " The muffin man, the muffin man,\n"
252    + " Do you know the muffin man,\n"
253    + " Who lives on Drury Lane?\n";
254  1 String muffin4 = "Do you know the muffin man,\n"
255    + " The muffin man, the muffin man,\n"
256    + " Do you know the muffin man,\n"
257    + " Who lives on Drury Lane?\n";
258  1 eq(muffin1, muffin2);
259  1 eq("\n" + muffin1, "\n" + muffin2);
260  1 eq("\n" + muffin1 + "\n", "\n" + muffin2 + "\n");
261  1 eq("\n " + muffin1 + "\n", "\n" + muffin3 + "\n");
262   
263  1 eq(muffin1.substring(1), muffin4);
264  1 eq("\n\t\n" + muffin1 + "\n", "\n\t\n" + muffin2 + "\n");
265  1 eq("\015\012" + muffin1, "\015\012" + muffin2);
266  1 eq("\015\012" + " Hello Again" + "\015\012" + " Said the Knight" + "\015\012",
267    "\015\012" + "Hello Again" + "\015\012" + "Said the Knight" + "\015\012");
268    }
269   
 
270  12 toggle public void eq(final String input, final String expected) throws Exception {
271  12 final StringBuffer buffer = new StringBuffer(input);
272  12 StringUtility.deleteLineLeadingWhitespace(buffer);
273  12 assertEquals(expected, buffer.toString());
274    }
275   
276    /**
277    * Test {@link StringUtility#escapeProperty(String)}.
278    *
279    * @throws Exception Test failed.
280    */
 
281  1 toggle public void testEscapeProperty() throws Exception {
282  1 assertEquals("\\u00E4\\u00FC\\u00F6\\u00DF\\u20AC\\u00C4\\u00DC\\u00D6\\u00B3",
283    StringUtility.escapeProperty("\u00E4\u00FC\u00F6\u00DF\u20AC\u00C4\u00DC\u00D6\u00B3"));
284    }
285   
286    /**
287    * Test {@link StringUtility#decodeXmlMarkup(StringBuffer)}.
288    *
289    * @throws Exception Test failed.
290    */
 
291  1 toggle public void testDecodeXmlMarkup() throws Exception {
292  1 final String test1 = "&amp;&lt;&gt;";
293  1 final StringBuffer buffer = new StringBuffer(test1);
294  1 assertEquals("&<>", StringUtility.decodeXmlMarkup(buffer));
295    }
296   
297    /**
298    * Test {@link StringUtility#decodeXmlMarkup(StringBuffer)}.
299    *
300    * @throws Exception Test failed.
301    */
 
302  0 toggle public void pestDecodeXmlMarkup() throws Exception {
303  0 final String test1 = "&#x3C;";
304  0 final StringBuffer buffer = new StringBuffer(test1);
305  0 assertEquals("<", StringUtility.decodeXmlMarkup(buffer));
306    }
307   
308    /**
309    * Test {@link StringUtility#hex2String(String).
310    *
311    * @throws Exception Test failed.
312    */
 
313  1 toggle public void testHex2String() throws Exception {
314  1 assertEquals("A", StringUtility.hex2String("41"));
315  1 assertEquals(" ", StringUtility.hex2String("20"));
316  1 assertEquals("0", StringUtility.hex2String("30"));
317  1 assertEquals("\015\012", StringUtility.hex2String("0D 0A"));
318  1 assertEquals("A", StringUtility.hex2String("41 "));
319  1 assertEquals(" ", StringUtility.hex2String("20 "));
320  1 assertEquals("0", StringUtility.hex2String("30 "));
321  1 assertEquals("\015\012", StringUtility.hex2String("0D 0A "));
322  1 assertEquals("A", StringUtility.hex2String(" 41"));
323  1 assertEquals(" ", StringUtility.hex2String(" 20"));
324  1 assertEquals("0", StringUtility.hex2String(" 30"));
325  1 assertEquals("\015\012", StringUtility.hex2String(" 0D 0A"));
326  1 assertEquals("A", StringUtility.hex2String("4 1"));
327  1 assertEquals(" ", StringUtility.hex2String("2 0"));
328  1 assertEquals("0", StringUtility.hex2String("3 0"));
329  1 assertEquals("\015\012", StringUtility.hex2String("0 D 0 A"));
330  1 assertEquals("A", StringUtility.hex2String("4\n1"));
331  1 assertEquals(" ", StringUtility.hex2String("\t2 \r0\n"));
332  1 assertEquals("0", StringUtility.hex2String("3 0"));
333  1 assertEquals("\015\012", StringUtility.hex2String(" 0 D0A"));
334  1 assertEquals("\352", StringUtility.hex2String("EA", "ISO-8859-1"));
335  1 assertEquals("\352", StringUtility.hex2String("ea", "ISO-8859-1"));
336  1 assertEquals("\352", StringUtility.hex2String("e A ", "ISO-8859-1"));
337  1 assertEquals("\000", StringUtility.hex2String("00"));
338   
339    // wrong padding
340  1 try {
341  1 StringUtility.hex2String("0");
342  0 fail("wrong number format exception expected");
343    } catch (IllegalArgumentException e) {
344    // expected
345    }
346  1 try {
347  1 StringUtility.hex2String("A01");
348  0 fail("wrong number format exception expected");
349    } catch (IllegalArgumentException e) {
350    // expected
351    }
352   
353    // wrong character
354  1 try {
355  1 StringUtility.hex2String("a+");
356  0 fail("wrong number format exception expected");
357    } catch (IllegalArgumentException e) {
358    // expected
359    }
360  1 try {
361  1 StringUtility.hex2String("!+");
362  0 fail("wrong number format exception expected");
363    } catch (IllegalArgumentException e) {
364    // expected
365    }
366  1 try {
367  1 StringUtility.hex2String("ZZ");
368  0 fail("wrong number format exception expected");
369    } catch (IllegalArgumentException e) {
370    // expected
371    }
372    }
373   
374    /**
375    * Test {@link StringUtility#string2Hex(String).
376    *
377    * @throws Exception Test failed.
378    */
 
379  1 toggle public void testString2Hex() throws Exception {
380  1 assertEquals("41", StringUtility.string2Hex("A"));
381  1 assertEquals("20", StringUtility.string2Hex(" "));
382  1 assertEquals("0D 0A", StringUtility.string2Hex("\015\012"));
383  1 assertEquals("EA", StringUtility.string2Hex("\352", "ISO-8859-1"));
384  1 assertEquals("0D 0A 0D 0A 0D 0A 0D 0A 0D 0A",
385    StringUtility.string2Hex("\015\012\015\012\015\012\015\012\015\012"));
386  1 assertEquals("0D 0A 0D 0A 0D 0A 0D 0A 0D 0A 20 20 20 20 20 20",
387    StringUtility.string2Hex(
388    "\015\012\015\012\015\012\015\012\015\012\040\040\040\040\040\040"));
389  1 assertEquals("0D 0A 0D 0A 0D 0A 0D 0A 0D 0A 20 20 20 20 20 20\n41",
390    StringUtility.string2Hex(
391    "\015\012\015\012\015\012\015\012\015\012\040\040\040\040\040\040A"));
392    }
393   
394    /**
395    * Test {@link StringUtility#string2Hex(String) and {@link StringUtility#hex2String(String)}.
396    *
397    * @throws Exception Test failed.
398    */
 
399  1 toggle public void testString2HexAndBack() throws Exception {
400  1 final String first = "All my Ducks in a Row!!!$%&<>/\\?";
401  1 assertEquals(first, StringUtility.hex2String(StringUtility.string2Hex(first)));
402  1 final String second = "41 42 43";
403  1 assertEquals(second, StringUtility.string2Hex(StringUtility.hex2String(second)));
404  1 StringBuffer third = new StringBuffer(256);
405  257 for (int i = 0; i < 256; i++) {
406  256 third.append((char) i);
407    }
408  1 assertEquals(third.toString(),
409    StringUtility.hex2String(StringUtility.string2Hex(third.toString())));
410  1 assertEquals(StringUtility.string2Hex(third.toString()),
411    StringUtility.string2Hex(StringUtility.hex2String(StringUtility.string2Hex(
412    third.toString()))));
413    }
414   
415    /**
416    * Test {@link StringUtility#format(long, int)}.
417    *
418    * @throws Exception Test failed.
419    */
 
420  1 toggle public void testFormat() throws Exception {
421  1 assertEquals("0", StringUtility.format(0, 1));
422  1 try {
423  1 assertEquals("0", StringUtility.format(0, 0));
424  0 fail("IllegalArgumentException expected");
425    } catch (IllegalArgumentException e) {
426    // expected
427    }
428  1 assertEquals("00123456", StringUtility.format(123456, 8));
429  1 assertEquals("00000000000000123456", StringUtility.format(123456, 20));
430  1 try {
431  1 assertEquals("00000000000000000000000123456", StringUtility.format(123456, 30));
432  0 fail("IllegalArgumentException expected");
433    } catch (IllegalArgumentException e) {
434    // expected
435    }
436  1 try {
437  1 assertEquals("000000000000000123456", StringUtility.format(123456, 21));
438  0 fail("IllegalArgumentException expected");
439    } catch (IllegalArgumentException e) {
440    // expected
441    }
442    }
443   
444    /**
445    * Test {@link StringUtility#getSystemLineSeparator()}.
446    *
447    * @throws Exception Test failed.
448    */
 
449  1 toggle public void testGetSystemLineSeparator() throws Exception {
450  1 assertEquals(System.getProperty("line.separator"),
451    StringUtility.getSystemLineSeparator());
452    }
453   
454    /**
455    * Test {@link StringUtility#useSystemLineSeparator(String)}.
456    *
457    * @throws Exception Test failed.
458    */
 
459  1 toggle public void testAddSystemLineSeparator() throws Exception {
460  1 assertEquals(null, StringUtility.useSystemLineSeparator(null));
461  1 assertEquals("" + System.getProperty("line.separator"),
462    StringUtility.useSystemLineSeparator("\015\012"));
463  1 assertEquals("asdfghj" + System.getProperty("line.separator"),
464    StringUtility.useSystemLineSeparator("asdfghj\015"));
465    }
466   
467    }
 
CloverReport generated by Clover Code Coverage v2.3.1
Sat Sep 18 2010 04:09:52 UTC.		   Clover: Open Source License registered to qedeq.org .