Spellchecker: remove some tests
[idea/community.git] / plugins / spellchecker / testSrc / com / intellij / spellchecker / inspector / SplitterTest.java
1 /*
2  * Copyright 2000-2009 JetBrains s.r.o.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package com.intellij.spellchecker.inspector;
17
18 import com.intellij.idea.Bombed;
19 import com.intellij.spellchecker.inspections.CheckArea;
20 import com.intellij.spellchecker.inspections.SplitterFactory;
21 import junit.framework.Assert;
22 import junit.framework.TestCase;
23 import org.jetbrains.annotations.NotNull;
24 import org.jetbrains.annotations.Nullable;
25
26 import java.io.BufferedReader;
27 import java.io.IOException;
28 import java.io.InputStream;
29 import java.io.InputStreamReader;
30 import java.util.ArrayList;
31 import java.util.Arrays;
32 import java.util.Calendar;
33 import java.util.List;
34
35
36 public class SplitterTest extends TestCase {
37
38
39   public void testSplitSimpleCamelCase() {
40     String text = "simpleCamelCase";
41     List<CheckArea> checkAreas = SplitterFactory.getInstance().getIdentifierSplitter().split(text);
42     correctListToCheck(checkAreas, text, new String[]{"simple", "Camel", "Case"});
43   }
44
45   public void testSplitCamelCaseWithUpperCasedWord() {
46     String text = "camelCaseJSP";
47     List<CheckArea> checkAreas = SplitterFactory.getInstance().getIdentifierSplitter().split(text);
48     correctListToCheck(checkAreas, text, new String[]{"camel", "Case"});
49   }
50
51    public void testArrays() {
52     String text = "Token[]";
53     List<CheckArea> checkAreas = SplitterFactory.getInstance().getIdentifierSplitter().split(text);
54     correctListToCheck(checkAreas, text, new String[]{"Token"});
55   }
56
57  /* public void testWordInBr1() {
58     String text = "'fill'";
59     List<CheckArea> checkAreas = SplitterFactory.getInstance().getIdentifierSplitter().split(text);
60     correctListToCheck(checkAreas, text, new String[]{"fill"});
61   }
62
63   public void testWordInBr2() {
64     String text = "\"fill\"";
65     List<CheckArea> checkAreas = SplitterFactory.getInstance().getIdentifierSplitter().split(text);
66     correctListToCheck(checkAreas, text, new String[]{"fill"});
67   }
68 */
69   public void testCapitalizedWithShortWords() {
70     String text = "IntelliJ";
71     List<CheckArea> checkAreas = SplitterFactory.getInstance().getIdentifierSplitter().split(text);
72     correctListToCheck(checkAreas, text, new String[]{});
73   }
74
75   public void testWords() {
76     String text = "first-last";
77     List<CheckArea> checkAreas = SplitterFactory.getInstance().getIdentifierSplitter().split(text);
78     correctListToCheck(checkAreas, text, new String[]{"first","last"});
79   }
80
81   public void testCapitalizedWithShortAndLongWords() {
82     String text = "IntelliJTestTest";
83     List<CheckArea> checkAreas = SplitterFactory.getInstance().getIdentifierSplitter().split(text);
84     correctListToCheck(checkAreas, text, new String[]{});
85   }
86
87   public void testWordWithApostrophe1() {
88     String text = "don't check";
89     List<CheckArea> checkAreas = SplitterFactory.getInstance().getStringLiteralSplitter().split(text);
90     correctListToCheck(checkAreas, text, new String[]{"don't", "check"});
91   }
92
93   public void testCheckXmlIgnored() {
94      String text = "abcdef" + new String(new char[]{0xDC00}) + "test";
95      List<CheckArea> checkAreas = SplitterFactory.getInstance().getPlainTextSplitter().split(text);
96      correctListToCheck(checkAreas, text, new String[]{});
97    }
98
99
100   public void testWordWithApostrophe2() {
101     String text = "customers'";
102     List<CheckArea> checkAreas = SplitterFactory.getInstance().getStringLiteralSplitter().split(text);
103     correctListToCheck(checkAreas, text, new String[]{"customers"});
104   }
105
106   public void testWordWithApostrophe3() {
107     String text = "customer's";
108     List<CheckArea> checkAreas = SplitterFactory.getInstance().getStringLiteralSplitter().split(text);
109     correctListToCheck(checkAreas, text, new String[]{"customer's"});
110   }
111
112
113   public void testWordWithApostrophe4() {
114     String text = "we'll";
115     List<CheckArea> checkAreas = SplitterFactory.getInstance().getStringLiteralSplitter().split(text);
116     correctListToCheck(checkAreas, text, new String[]{"we'll"});
117   }
118
119   public void testWordWithApostrophe5() {
120     String text = "I'm you're we'll";
121     List<CheckArea> checkAreas = SplitterFactory.getInstance().getStringLiteralSplitter().split(text);
122     correctListToCheck(checkAreas, text, new String[]{"you're", "we'll"});
123   }
124
125   public void testConstantName() {
126     String text = "TEST_CONSTANT";
127     List<CheckArea> checkAreas = SplitterFactory.getInstance().getIdentifierSplitter().split(text);
128     correctListToCheck(checkAreas, text, new String[]{"TEST", "CONSTANT"});
129     
130   }
131
132   public void testLongConstantName() {
133     String text = "TEST_VERY_VERY_LONG_AND_COMPLEX_CONSTANT";
134     List<CheckArea> checkAreas = SplitterFactory.getInstance().getIdentifierSplitter().split(text);
135     correctListToCheck(checkAreas, text, new String[]{"TEST", "VERY", "VERY", "LONG", "COMPLEX", "CONSTANT"});
136    
137   }
138
139   public void testJavaComments() {
140     String text = "/*special symbols*/";
141     List<CheckArea> checkAreas = SplitterFactory.getInstance().getCommentSplitter().split(text);
142     correctListToCheck(checkAreas, text, new String[]{"special", "symbols"});
143     
144   }
145
146
147   public void testXmlComments() {
148     String text = "<!--special symbols-->";
149     List<CheckArea> checkAreas = SplitterFactory.getInstance().getCommentSplitter().split(text);
150     correctListToCheck(checkAreas, text, new String[]{"special", "symbols"});
151     
152   }
153
154   public void testCamelCaseInXmlComments() {
155     String text = "<!--specialCase symbols-->";
156     List<CheckArea> checkAreas = SplitterFactory.getInstance().getCommentSplitter().split(text);
157     correctListToCheck(checkAreas, text, new String[]{"special", "Case", "symbols"});
158     
159   }
160
161   public void testWordsWithNumbers() {
162     String text = "testCamelCase123";
163     List<CheckArea> checkAreas = SplitterFactory.getInstance().getIdentifierSplitter().split(text);
164     correctListToCheck(checkAreas, text, new String[]{"test", "Camel", "Case"});
165     
166   }
167
168   public void testCommentsWithWordsWithNumbers() {
169     String text = "<!--specialCase456 symbols-->";
170     List<CheckArea> checkAreas = SplitterFactory.getInstance().getCommentSplitter().split(text);
171     correctListToCheck(checkAreas, text, new String[]{"special", "Case", "symbols"});
172     
173   }
174
175   public void testCommentsWithAbr() {
176     String text = "<!--JSPTestClass-->";
177     List<CheckArea> checkAreas = SplitterFactory.getInstance().getCommentSplitter().split(text);
178     correctListToCheck(checkAreas, text, new String[]{"Test", "Class"});
179     
180   }
181
182   public void testStringLiterals() {
183     String text = "test\ntest\n";
184     List<CheckArea> checkAreas = SplitterFactory.getInstance().getStringLiteralSplitter().split(text);
185     correctListToCheck(checkAreas, text, new String[]{"test", "test"});
186     
187   }
188
189
190   public void testCommentWithHtml() {
191     String text = "<!--<li>something go here</li> <li>next content</li> foooo barrrr <p> text -->";
192     List<CheckArea> checkAreas = SplitterFactory.getInstance().getCommentSplitter().split(text);
193     correctListToCheck(checkAreas, text, new String[]{"something", "here", "next", "content", "foooo", "barrrr", "text"});
194     
195   }
196
197   public void testCommentWithHtmlTagsAndAtr() {
198     String text = "<!-- <li style='color:red;'>something go here</li> foooo <li style='color:red;'>barrrr</li> <p> text text -->";
199     List<CheckArea> checkAreas = SplitterFactory.getInstance().getCommentSplitter().split(text);
200     correctListToCheck(checkAreas, text, new String[]{"something", "here", "foooo", "barrrr", "text", "text"});
201     
202   }
203
204   public void testSpecial() {
205     String text = "test &nbsp; test";
206     List<CheckArea> checkAreas = SplitterFactory.getInstance().getPlainTextSplitter().split(text);
207     correctListToCheck(checkAreas, text, new String[]{"test", "test"});
208     
209   }
210
211   public void testColorUC() {
212     String text = "#AABBFF";
213     List<CheckArea> checkAreas = SplitterFactory.getInstance().getAttributeValueSplitter().split(text);
214     correctListToCheck(checkAreas, text, new String[]{});
215     
216   }
217
218    public void testColorUCSurrounded() {
219     String text = "\"#AABBFF\"";
220     List<CheckArea> checkAreas = SplitterFactory.getInstance().getAttributeValueSplitter().split(text);
221     correctListToCheck(checkAreas, text, new String[]{});
222     
223   }
224
225   public void testColorLC() {
226     String text = "#fff";
227     List<CheckArea> checkAreas = SplitterFactory.getInstance().getAttributeValueSplitter().split(text);
228     correctListToCheck(checkAreas, text, new String[]{});
229     
230   }
231
232   public void testTooShort() {
233     String text = "bgColor carLight";
234     List<CheckArea> checkAreas = SplitterFactory.getInstance().getStringLiteralSplitter().split(text);
235     correctListToCheck(checkAreas, text, new String[]{"Color", "Light"});
236     
237   }
238
239    public void testPhpVariableCorrectSimple() {
240     String text = "$this";
241     List<CheckArea> checkAreas = SplitterFactory.getInstance().getIdentifierSplitter().split(text);
242     correctListToCheck(checkAreas, text, new String[]{"this"});
243
244   }
245
246   public void testPhpVariableCorrect() {
247     String text = "$this_this$this";
248     List<CheckArea> checkAreas = SplitterFactory.getInstance().getIdentifierSplitter().split(text);
249     correctListToCheck(checkAreas, text, new String[]{"this","this","this"});
250
251   }
252
253   public void testEmail() {
254     String text = "some text with email (shkate.test@gmail.com) inside";
255     List<CheckArea> checkAreas = SplitterFactory.getInstance().getStringLiteralSplitter().split(text);
256     correctListToCheck(checkAreas, text, new String[]{"some","text","with","email","inside"});
257     
258   }
259
260   public void testEmailOnly() {
261     String text = "shkate123-\u00DC.test@gmail.com";
262     List<CheckArea> checkAreas = SplitterFactory.getInstance().getPlainTextSplitter().split(text);
263     correctListToCheck(checkAreas, text, new String[]{});
264     
265   }
266
267   public void testUrl() {
268     String text = "http://www.jetbrains.com/idea";
269     List<CheckArea> checkAreas = SplitterFactory.getInstance().getPlainTextSplitter().split(text);
270     correctListToCheck(checkAreas, text, new String[]{});
271  
272   }
273
274   public void testWordBeforeDelimiter() {
275     String text = "badd,";
276     List<CheckArea> checkAreas = SplitterFactory.getInstance().getPlainTextSplitter().split(text);
277     correctListToCheck(checkAreas, text, new String[]{"badd"});
278  
279   }
280
281   public void testWordAfterDelimiter() {
282     String text = ",badd";
283     List<CheckArea> checkAreas = SplitterFactory.getInstance().getPlainTextSplitter().split(text);
284     correctListToCheck(checkAreas, text, new String[]{"badd"});
285      
286   }
287
288   public void testWordInCapsBeforeDelimiter() {
289     String text = "BADD,";
290     List<CheckArea> checkAreas = SplitterFactory.getInstance().getPlainTextSplitter().split(text);
291     correctListToCheck(checkAreas, text, new String[]{"BADD"});
292      
293   }
294
295   public void testWordInCapsAfterDelimiter() {
296     String text = ",BADD";
297     List<CheckArea> checkAreas = SplitterFactory.getInstance().getPlainTextSplitter().split(text);
298     correctListToCheck(checkAreas, text, new String[]{"BADD"});
299      
300   }
301
302   public void testWordInCapsAfterDelimiter2() {
303     String text = "BADD;";
304     List<CheckArea> checkAreas = SplitterFactory.getInstance().getPlainTextSplitter().split(text);
305     correctListToCheck(checkAreas, text, new String[]{"BADD"});
306      
307   }
308
309   public void testWordInCapsAfterDelimiter3() {
310     String text = ";BADD;";
311     List<CheckArea> checkAreas = SplitterFactory.getInstance().getPlainTextSplitter().split(text);
312     correctListToCheck(checkAreas, text, new String[]{"BADD"});
313      
314   }
315
316   public void testWordWithUmlauts() {
317     String text = "rechtsb\u00FCndig";
318     List<CheckArea> checkAreas = SplitterFactory.getInstance().getPlainTextSplitter().split(text);
319     correctListToCheck(checkAreas, text, new String[]{text});
320      
321   }
322
323
324   public void testWordUpperCasedWithUmlauts() {
325     String text = "RECHTSB\u00DCNDIG";
326     List<CheckArea> checkAreas = SplitterFactory.getInstance().getPlainTextSplitter().split(text);
327     correctListToCheck(checkAreas, text, new String[]{text});
328      
329   }
330
331   public void testCommaSeparatedList() {
332     String text = "properties,test,properties";
333     List<CheckArea> checkAreas = SplitterFactory.getInstance().getPlainTextSplitter().split(text);
334     correctListToCheck(checkAreas, text, new String[]{"properties", "test", "properties"});
335      
336   }
337
338   public void testSemicolonSeparatedList() {
339     String text = "properties;test;properties";
340     List<CheckArea> checkAreas = SplitterFactory.getInstance().getPlainTextSplitter().split(text);
341     correctListToCheck(checkAreas, text, new String[]{"properties", "test", "properties"});
342      
343   }
344
345   public void testProperties1() {
346     String text = "properties.test.properties";
347     List<CheckArea> checkAreas = SplitterFactory.getInstance().getPropertiesSplitter().split(text);
348     correctListToCheck(checkAreas, text, new String[]{"properties", "test", "properties"});
349      
350   }
351
352
353   public void testPropertiesWithCamelCase() {
354     String text = "upgrade.testCommit.propertiesSomeNews";
355      List<CheckArea> checkAreas = SplitterFactory.getInstance().getPropertiesSplitter().split(text);
356     correctListToCheck(checkAreas, text, new String[]{"upgrade", "test", "Commit", "properties","Some","News"});
357      
358   }
359
360   public void testWordUpperCasedWithUmlautsInTheBeginning() {
361     String text = "\u00DCNDIG";
362       List<CheckArea> checkAreas = SplitterFactory.getInstance().getPlainTextSplitter().split(text);
363     correctListToCheck(checkAreas, text, new String[]{text});
364      
365   }
366
367   
368
369  
370
371   public void testTCData() {
372     final InputStream stream = SplitterTest.class.getResourceAsStream("contents.txt");
373     String text = convertStreamToString(stream);
374     List<CheckArea> checkAreas = SplitterFactory.getInstance().getPlainTextSplitter().split(text);
375     List<String> words = wordsToCheck(checkAreas, text);
376     assertNull(words);
377   }
378
379  
380
381
382   @Nullable
383   private static List<String> wordsToCheck(List<CheckArea> toCheck, String text) {
384     if (text == null || toCheck == null) return null;
385     List<String> words = new ArrayList<String>();
386     for (CheckArea area : toCheck) {
387       if (!area.isIgnored()) {
388         words.add(area.getWord());
389       }
390     }
391     return (words.size() != 0) ? words : null;
392   }
393
394
395   @Nullable
396   private static List<String> wordsToIgnore(List<CheckArea> toCheck, String text) {
397     if (text == null || toCheck == null) return null;
398     List<String> words = new ArrayList<String>();
399     for (CheckArea area : toCheck) {
400       if (area.isIgnored()) {
401         words.add(area.getWord());
402       }
403     }
404     return (words.size() != 0) ? words : null;
405   }
406
407   private static void correctListToCheck(List<CheckArea> toCheck, String text, @NotNull String[] expected) {
408     List<String> words = wordsToCheck(toCheck, text);
409     if (expected.length == 0) {
410       Assert.assertNull(words);
411     }
412     else {
413       Assert.assertNotNull(words);
414       Assert.assertEquals(expected.length, words.size());
415       List<String> expectedWords = Arrays.asList(expected);
416       Assert.assertEquals(expectedWords, words);
417     }
418   }
419
420  
421
422   private String convertStreamToString(InputStream is) {
423     if (is != null) {
424       StringBuilder sb = new StringBuilder();
425       String line;
426
427       try {
428         BufferedReader reader = new BufferedReader(new InputStreamReader(is, "UTF-8"));
429         while ((line = reader.readLine()) != null) {
430           sb.append(line).append("\n");
431         }
432       }
433       catch (Exception e) {
434         throw new RuntimeException(e);
435       }
436       finally {
437         try {
438           is.close();
439         }
440         catch (IOException ignore) {
441
442         }
443       }
444       return sb.toString();
445     }
446     else {
447       return "";
448     }
449   }
450 }