KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > gargoylesoftware > htmlunit > TextUtilTest


1 /*
2  * Copyright (c) 2002, 2005 Gargoyle Software Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions are met:
6  *
7  * 1. Redistributions of source code must retain the above copyright notice,
8  * this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright notice,
10  * this list of conditions and the following disclaimer in the documentation
11  * and/or other materials provided with the distribution.
12  * 3. The end-user documentation included with the redistribution, if any, must
13  * include the following acknowledgment:
14  *
15  * "This product includes software developed by Gargoyle Software Inc.
16  * (http://www.GargoyleSoftware.com/)."
17  *
18  * Alternately, this acknowledgment may appear in the software itself, if
19  * and wherever such third-party acknowledgments normally appear.
20  * 4. The name "Gargoyle Software" must not be used to endorse or promote
21  * products derived from this software without prior written permission.
22  * For written permission, please contact info@GargoyleSoftware.com.
23  * 5. Products derived from this software may not be called "HtmlUnit", nor may
24  * "HtmlUnit" appear in their name, without prior written permission of
25  * Gargoyle Software Inc.
26  *
27  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
28  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
29  * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GARGOYLE
30  * SOFTWARE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
31  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
32  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
33  * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
34  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
35  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
36  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
37  */
38 package com.gargoylesoftware.htmlunit;
39
40 import java.io.BufferedReader;
41 import java.io.InputStream;
42 import java.io.InputStreamReader;
43
44 /**
45  * Tests for TextUtil.
46  *
47  * @version $Revision: 1.8 $
48  * @author <a HREF="mailto:mbowler@GargoyleSoftware.com">Mike Bowler</a>
49  */
50 public final class TextUtilTest extends WebTestCase {
51     /**
52      * Create an instance.
53      * @param name The name of the test.
54      */
55     public TextUtilTest( final String name ) {
56         super(name);
57     }
58
59
60     /**
61      * Test startsWithIgnoreCase() with null values.
62      */
63     public void testStartsWithIgnoreCase_nulls() {
64         try {
65             TextUtil.startsWithIgnoreCase(null, "foo");
66             fail("Expected null pointer exception");
67         }
68         catch( final NullPointerException e ) {
69             // Expected path
70 }
71
72         try {
73             TextUtil.startsWithIgnoreCase("foo", null);
74             fail("Expected null pointer exception");
75         }
76         catch( final NullPointerException e ) {
77             // Expected path
78 }
79     }
80
81
82     /**
83      * Test startsWithIgnoreCase() with an empty prefix
84      */
85     public void testStartsWithIgnoreCase_emptyPrefix() {
86         try {
87             TextUtil.startsWithIgnoreCase("foo", "");
88             fail("Expected IllegalArgumentException");
89         }
90         catch( final IllegalArgumentException e ) {
91             // Expected path
92 }
93     }
94
95
96     /**
97      * Test a variety of cases that should return true.
98      */
99     public void testStartsWithIgnoreCase_ShouldReturnTrue() {
100         final String[][] data = {
101             {"foo","foo"},
102             {"foo:bar","foo"},
103             {"FOO:BAR","foo"},
104             {"foo:bar","FOO"},
105         };
106
107         for( int i=0; i<data.length; i++ ) {
108             final String stringToCheck = data[i][0];
109             final String prefix = data[i][1];
110
111             assertTrue(
112                 "stringToCheck=["+stringToCheck+"] prefix=["+prefix+"]",
113                 TextUtil.startsWithIgnoreCase(stringToCheck, prefix));
114         }
115     }
116
117
118     /**
119      * Test a variety of cases that should return false.
120      */
121     public void testStartsWithIgnoreCase_ShouldReturnFalse() {
122         final String[][] data = {
123             {"","foo"},
124             {"fobar","foo"},
125             {"fo","foo"},
126         };
127
128         for( int i=0; i<data.length; i++ ) {
129             final String stringToCheck = data[i][0];
130             final String prefix = data[i][1];
131
132             assertFalse(
133                 "stringToCheck=["+stringToCheck+"] prefix=["+prefix+"]",
134                 TextUtil.startsWithIgnoreCase(stringToCheck, prefix));
135         }
136     }
137
138     /**
139      * @throws Exception if the test fails
140      */
141     public void testToInputStream_null() throws Exception {
142         try {
143             TextUtil.toInputStream(null);
144             fail("Expected NullPointerException");
145         }
146         catch( final NullPointerException e ) {
147             // Expected path
148 }
149     }
150
151
152     /**
153      * @throws Exception if the test fails
154      */
155     public void testToInputStream() throws Exception {
156         final String[][] data = {
157             {"", null},
158             {"a", "a"},
159             {"abcdefABCDEF", "abcdefABCDEF"},
160         };
161         final String encoding = "ISO-8859-1";
162
163         for( int i=0; i<data.length; i++ ) {
164             final String input = data[i][0];
165             final String expectedResult = data[i][1];
166
167             final InputStream inputStream = TextUtil.toInputStream(input, encoding);
168             final String actualResult
169                 = new BufferedReader( new InputStreamReader(inputStream, encoding) ).readLine();
170             assertEquals( expectedResult, actualResult);
171         }
172     }
173 }
174
Popular Tags