1
2
3
4 package net.sourceforge.pmd;
5
6 import static org.junit.Assert.assertEquals;
7 import static org.junit.Assert.assertFalse;
8 import static org.junit.Assert.assertNotNull;
9 import static org.junit.Assert.assertNotSame;
10 import static org.junit.Assert.assertNull;
11 import static org.junit.Assert.assertTrue;
12
13 import java.io.ByteArrayInputStream;
14 import java.io.InputStream;
15 import java.io.UnsupportedEncodingException;
16 import java.util.HashSet;
17 import java.util.Set;
18
19 import net.sourceforge.pmd.lang.DummyLanguageModule;
20 import net.sourceforge.pmd.lang.LanguageRegistry;
21 import net.sourceforge.pmd.lang.rule.MockRule;
22 import net.sourceforge.pmd.lang.rule.RuleReference;
23 import net.sourceforge.pmd.util.ResourceLoader;
24
25 import org.junit.Assert;
26 import org.junit.Test;
27
28 public class RuleSetFactoryTest {
29 @Test
30 public void testRuleSetFileName() throws RuleSetNotFoundException {
31 RuleSet rs = loadRuleSet(EMPTY_RULESET);
32 assertNull("RuleSet file name not expected", rs.getFileName());
33
34 RuleSetFactory rsf = new RuleSetFactory();
35 rs = rsf.createRuleSet("net/sourceforge/pmd/TestRuleset1.xml");
36 assertEquals("wrong RuleSet file name", rs.getFileName(),
37 "net/sourceforge/pmd/TestRuleset1.xml");
38 }
39
40 @Test
41 public void testNoRuleSetFileName() throws RuleSetNotFoundException {
42 RuleSet rs = loadRuleSet(EMPTY_RULESET);
43 assertNull("RuleSet file name not expected", rs.getFileName());
44 }
45
46 @Test
47 public void testRefs() throws Throwable {
48 RuleSetFactory rsf = new RuleSetFactory();
49 RuleSet rs = rsf.createRuleSet("net/sourceforge/pmd/TestRuleset1.xml");
50 assertNotNull(rs.getRuleByName("TestRuleRef"));
51 }
52
53 @Test
54 public void testExtendedReferences() throws Exception {
55 InputStream in = ResourceLoader.loadResourceAsStream("net/sourceforge/pmd/rulesets/reference-ruleset.xml",
56 this.getClass().getClassLoader());
57 Assert.assertNotNull("Test ruleset not found - can't continue with test!", in);
58
59 RuleSetFactory rsf = new RuleSetFactory();
60 RuleSets rs = rsf.createRuleSets("net/sourceforge/pmd/rulesets/reference-ruleset.xml");
61
62 assertNotNull(rs.getRuleByName("MockRule1"));
63 assertNotNull(rs.getRuleByName("MockRule2"));
64 assertNotNull(rs.getRuleByName("MockRule3"));
65 assertNotNull(rs.getRuleByName("TestRuleRef"));
66
67
68 assertNotNull(rs.getRuleByName("TestRule"));
69
70 assertNull(rs.getRuleByName("TestRule2Ruleset2"));
71
72 Rule mockRule3 = rs.getRuleByName("MockRule3");
73 assertEquals("Overridden message", mockRule3.getMessage());
74 assertEquals(2, mockRule3.getPriority().getPriority());
75
76 Rule mockRule2 = rs.getRuleByName("MockRule2");
77 assertEquals("Just combine them!", mockRule2.getMessage());
78
79
80 assertEquals(1, countRule(rs, "MockRule2"));
81
82 Rule mockRule1 = rs.getRuleByName("MockRule1");
83 assertNotNull(mockRule1);
84 PropertyDescriptor<?> prop = mockRule1.getPropertyDescriptor("testIntProperty");
85 Object property = mockRule1.getProperty(prop);
86 assertEquals("5", String.valueOf(property));
87
88
89 assertNotNull(rs.getRuleByName("Ruleset3Rule2"));
90
91 assertNull(rs.getRuleByName("Ruleset3Rule1"));
92
93
94 Rule ruleset4Rule1 = rs.getRuleByName("Ruleset4Rule1");
95 assertNotNull(ruleset4Rule1);
96 assertEquals(5, ruleset4Rule1.getPriority().getPriority());
97 assertEquals(1, countRule(rs, "Ruleset4Rule1"));
98
99 Rule ruleset4Rule2 = rs.getRuleByName("Ruleset4Rule2");
100 assertNotNull(ruleset4Rule2);
101 assertEquals(2, ruleset4Rule2.getPriority().getPriority());
102 }
103
104 private int countRule(RuleSets rs, String ruleName) {
105 int count = 0;
106 for (Rule r : rs.getAllRules()) {
107 if (ruleName.equals(r.getName())) {
108 count++;
109 }
110 }
111 return count;
112 }
113
114 @Test(expected = RuleSetNotFoundException.class)
115 public void testRuleSetNotFound() throws RuleSetNotFoundException {
116 RuleSetFactory rsf = new RuleSetFactory();
117 rsf.createRuleSet("fooooo");
118 }
119
120 @Test
121 public void testCreateEmptyRuleSet() throws RuleSetNotFoundException {
122 RuleSet rs = loadRuleSet(EMPTY_RULESET);
123 assertEquals("test", rs.getName());
124 assertEquals(0, rs.size());
125 }
126
127 @Test
128 public void testSingleRule() throws RuleSetNotFoundException {
129 RuleSet rs = loadRuleSet(SINGLE_RULE);
130 assertEquals(1, rs.size());
131 Rule r = rs.getRules().iterator().next();
132 assertEquals("MockRuleName", r.getName());
133 assertEquals("net.sourceforge.pmd.lang.rule.MockRule", r.getRuleClass());
134 assertEquals("avoid the mock rule", r.getMessage());
135 }
136
137 @Test
138 public void testMultipleRules() throws RuleSetNotFoundException {
139 RuleSet rs = loadRuleSet(MULTIPLE_RULES);
140 assertEquals(2, rs.size());
141 Set<String> expected = new HashSet<String>();
142 expected.add("MockRuleName1");
143 expected.add("MockRuleName2");
144 for (Rule rule : rs.getRules()) {
145 assertTrue(expected.contains(rule.getName()));
146 }
147 }
148
149 @Test
150 public void testSingleRuleWithPriority() throws RuleSetNotFoundException {
151 assertEquals(RulePriority.MEDIUM, loadFirstRule(PRIORITY).getPriority());
152 }
153
154 @Test
155 @SuppressWarnings("unchecked")
156 public void testProps() throws RuleSetNotFoundException {
157 Rule r = loadFirstRule(PROPERTIES);
158 assertEquals("bar", r.getProperty((PropertyDescriptor<String>) r.getPropertyDescriptor("fooString")));
159 assertEquals(new Integer(3), r.getProperty((PropertyDescriptor<Integer>) r.getPropertyDescriptor("fooInt")));
160 assertTrue(r.getProperty((PropertyDescriptor<Boolean>) r.getPropertyDescriptor("fooBoolean")));
161 assertEquals(3.0d, r.getProperty((PropertyDescriptor<Double>) r.getPropertyDescriptor("fooDouble")), 0.05);
162 assertNull(r.getPropertyDescriptor("BuggleFish"));
163 assertNotSame(r.getDescription().indexOf("testdesc2"), -1);
164 }
165
166 @Test
167 public void testStringMultiPropertyDefaultDelimiter() throws Exception {
168 Rule r = loadFirstRule("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
169 "<ruleset>\n" +
170 " <rule name=\"myRule\" message=\"Do not place to this package. Move to \n" +
171 "{0} package/s instead.\" \n" +
172 "class=\"net.sourceforge.pmd.lang.rule.XPathRule\" " +
173 "language=\"dummy\">\n" +
174 " <description>Please move your class to the right folder(rest \n" +
175 "folder)</description>\n" +
176 " <priority>2</priority>\n" +
177 " <properties>\n" +
178 " <property name=\"packageRegEx\" value=\"com.aptsssss|com.abc\" \n" +
179 "type=\"String[]\" description=\"valid packages\"/>\n" +
180 " </properties>"
181 + "</rule>"
182 + "</ruleset>");
183 PropertyDescriptor<?> prop = r.getPropertyDescriptor("packageRegEx");
184 String[] values = (String[])r.getProperty(prop);
185 Assert.assertArrayEquals(new String[]{"com.aptsssss", "com.abc"}, values);
186 }
187
188 @Test
189 public void testStringMultiPropertyDelimiter() throws Exception {
190 Rule r = loadFirstRule("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
191 "<ruleset>\n" +
192 " <rule name=\"myRule\" message=\"Do not place to this package. Move to \n" +
193 "{0} package/s instead.\" \n" +
194 "class=\"net.sourceforge.pmd.lang.rule.XPathRule\" " +
195 "language=\"dummy\">\n" +
196 " <description>Please move your class to the right folder(rest \n" +
197 "folder)</description>\n" +
198 " <priority>2</priority>\n" +
199 " <properties>\n" +
200 " <property name=\"packageRegEx\" value=\"com.aptsssss,com.abc\" \n" +
201 "type=\"String[]\" delimiter=\",\" description=\"valid packages\"/>\n" +
202 " </properties>"
203 + "</rule>"
204 + "</ruleset>");
205 PropertyDescriptor<?> prop = r.getPropertyDescriptor("packageRegEx");
206 String[] values = (String[])r.getProperty(prop);
207 Assert.assertArrayEquals(new String[]{"com.aptsssss", "com.abc"}, values);
208 }
209
210 @Test
211 public void testRuleSetWithDeprecatedRule() throws Exception {
212 RuleSet rs = loadRuleSet("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
213 "<ruleset>\n" +
214 " <rule deprecated=\"true\" ref=\"rulesets/dummy/basic.xml/DummyBasicMockRule\"/>"
215 + "</ruleset>");
216 Assert.assertEquals(1, rs.getRules().size());
217 Rule rule = rs.getRuleByName("DummyBasicMockRule");
218 Assert.assertNotNull(rule);
219 }
220
221 @Test
222 public void testRuleSetWithDeprecatedButRenamedRule() throws Exception {
223 RuleSet rs = loadRuleSet("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
224 "<ruleset>\n" +
225 " <rule deprecated=\"true\" ref=\"NewName\" name=\"OldName\"/>" +
226 " <rule name=\"NewName\" message=\"m\" class=\"net.sourceforge.pmd.lang.rule.XPathRule\" language=\"dummy\">" +
227 " <description>d</description>\n" +
228 " <priority>2</priority>\n" +
229 " </rule>"
230 + "</ruleset>");
231 Assert.assertEquals(1, rs.getRules().size());
232 Rule rule = rs.getRuleByName("NewName");
233 Assert.assertNotNull(rule);
234 Assert.assertNull(rs.getRuleByName("OldName"));
235 }
236
237 @Test
238 public void testRuleSetReferencesADeprecatedRenamedRule() throws Exception {
239 RuleSet rs = loadRuleSet("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
240 "<ruleset>\n" +
241 " <rule ref=\"rulesets/dummy/basic.xml/OldNameOfDummyBasicMockRule\"/>"
242 + "</ruleset>");
243 Assert.assertEquals(1, rs.getRules().size());
244 Rule rule = rs.getRuleByName("OldNameOfDummyBasicMockRule");
245 Assert.assertNotNull(rule);
246 }
247
248 @Test
249 @SuppressWarnings("unchecked")
250 public void testXPath() throws RuleSetNotFoundException {
251 Rule r = loadFirstRule(XPATH);
252 PropertyDescriptor<String> xpathProperty = (PropertyDescriptor<String>) r.getPropertyDescriptor("xpath");
253 assertNotNull("xpath property descriptor", xpathProperty);
254 assertNotSame(r.getProperty(xpathProperty).indexOf(" //Block "), -1);
255 }
256
257 @Test
258 public void testFacadesOffByDefault() throws RuleSetNotFoundException {
259 Rule r = loadFirstRule(XPATH);
260 assertFalse(r.usesDFA());
261 }
262
263 @Test
264 public void testDFAFlag() throws RuleSetNotFoundException {
265 assertTrue(loadFirstRule(DFA).usesDFA());
266 }
267
268 @Test
269 public void testExternalReferenceOverride() throws RuleSetNotFoundException {
270 Rule r = loadFirstRule(REF_OVERRIDE);
271 assertEquals("TestNameOverride", r.getName());
272 assertEquals("Test message override", r.getMessage());
273 assertEquals("Test description override", r.getDescription());
274 assertEquals("Test that both example are stored", 2, r.getExamples().size());
275 assertEquals("Test example override", r.getExamples().get(1));
276 assertEquals(RulePriority.MEDIUM, r.getPriority());
277 PropertyDescriptor<?> test2Descriptor = r.getPropertyDescriptor("test2");
278 assertNotNull("test2 descriptor", test2Descriptor);
279 assertEquals("override2", r.getProperty(test2Descriptor));
280 PropertyDescriptor<?> test3Descriptor = r.getPropertyDescriptor("test3");
281 assertNotNull("test3 descriptor", test3Descriptor);
282 assertEquals("override3", r.getProperty(test3Descriptor));
283 PropertyDescriptor<?> test4Descriptor = r.getPropertyDescriptor("test4");
284 assertNotNull("test3 descriptor", test4Descriptor);
285 assertEquals("new property", r.getProperty(test4Descriptor));
286 }
287
288 @Test
289 public void testReferenceInternalToInternal()
290 throws RuleSetNotFoundException {
291 RuleSet ruleSet = loadRuleSet(REF_INTERNAL_TO_INTERNAL);
292
293 Rule rule = ruleSet.getRuleByName("MockRuleName");
294 assertNotNull("Could not find Rule MockRuleName", rule);
295
296 Rule ruleRef = ruleSet.getRuleByName("MockRuleNameRef");
297 assertNotNull("Could not find Rule MockRuleNameRef", ruleRef);
298 }
299
300 @Test
301 public void testReferenceInternalToInternalChain()
302 throws RuleSetNotFoundException {
303 RuleSet ruleSet = loadRuleSet(REF_INTERNAL_TO_INTERNAL_CHAIN);
304
305 Rule rule = ruleSet.getRuleByName("MockRuleName");
306 assertNotNull("Could not find Rule MockRuleName", rule);
307
308 Rule ruleRef = ruleSet.getRuleByName("MockRuleNameRef");
309 assertNotNull("Could not find Rule MockRuleNameRef", ruleRef);
310
311 Rule ruleRefRef = ruleSet.getRuleByName("MockRuleNameRefRef");
312 assertNotNull("Could not find Rule MockRuleNameRefRef", ruleRefRef);
313 }
314
315 @Test
316 public void testReferenceInternalToExternal()
317 throws RuleSetNotFoundException {
318 RuleSet ruleSet = loadRuleSet(REF_INTERNAL_TO_EXTERNAL);
319
320 Rule rule = ruleSet.getRuleByName("ExternalRefRuleName");
321 assertNotNull("Could not find Rule ExternalRefRuleName", rule);
322
323 Rule ruleRef = ruleSet.getRuleByName("ExternalRefRuleNameRef");
324 assertNotNull("Could not find Rule ExternalRefRuleNameRef", ruleRef);
325 }
326
327 @Test
328 public void testReferenceInternalToExternalChain()
329 throws RuleSetNotFoundException {
330 RuleSet ruleSet = loadRuleSet(REF_INTERNAL_TO_EXTERNAL_CHAIN);
331
332 Rule rule = ruleSet.getRuleByName("ExternalRefRuleName");
333 assertNotNull("Could not find Rule ExternalRefRuleName", rule);
334
335 Rule ruleRef = ruleSet.getRuleByName("ExternalRefRuleNameRef");
336 assertNotNull("Could not find Rule ExternalRefRuleNameRef", ruleRef);
337
338 Rule ruleRefRef = ruleSet.getRuleByName("ExternalRefRuleNameRefRef");
339 assertNotNull("Could not find Rule ExternalRefRuleNameRefRef",
340 ruleRefRef);
341 }
342
343 @Test
344 public void testReferencePriority() throws RuleSetNotFoundException {
345 RuleSetFactory rsf = new RuleSetFactory();
346
347 rsf.setMinimumPriority(RulePriority.LOW);
348 RuleSet ruleSet = rsf
349 .createRuleSet(createRuleSetReferenceId(REF_INTERNAL_TO_INTERNAL_CHAIN));
350 assertEquals("Number of Rules", 3, ruleSet.getRules().size());
351 assertNotNull(ruleSet.getRuleByName("MockRuleName"));
352 assertNotNull(ruleSet.getRuleByName("MockRuleNameRef"));
353 assertNotNull(ruleSet.getRuleByName("MockRuleNameRefRef"));
354
355 rsf.setMinimumPriority(RulePriority.MEDIUM_HIGH);
356 ruleSet = rsf
357 .createRuleSet(createRuleSetReferenceId(REF_INTERNAL_TO_INTERNAL_CHAIN));
358 assertEquals("Number of Rules", 2, ruleSet.getRules().size());
359 assertNotNull(ruleSet.getRuleByName("MockRuleNameRef"));
360 assertNotNull(ruleSet.getRuleByName("MockRuleNameRefRef"));
361
362 rsf.setMinimumPriority(RulePriority.HIGH);
363 ruleSet = rsf
364 .createRuleSet(createRuleSetReferenceId(REF_INTERNAL_TO_INTERNAL_CHAIN));
365 assertEquals("Number of Rules", 1, ruleSet.getRules().size());
366 assertNotNull(ruleSet.getRuleByName("MockRuleNameRefRef"));
367
368 rsf.setMinimumPriority(RulePriority.LOW);
369 ruleSet = rsf
370 .createRuleSet(createRuleSetReferenceId(REF_INTERNAL_TO_EXTERNAL_CHAIN));
371 assertEquals("Number of Rules", 3, ruleSet.getRules().size());
372 assertNotNull(ruleSet.getRuleByName("ExternalRefRuleName"));
373 assertNotNull(ruleSet.getRuleByName("ExternalRefRuleNameRef"));
374 assertNotNull(ruleSet.getRuleByName("ExternalRefRuleNameRefRef"));
375
376 rsf.setMinimumPriority(RulePriority.MEDIUM_HIGH);
377 ruleSet = rsf
378 .createRuleSet(createRuleSetReferenceId(REF_INTERNAL_TO_EXTERNAL_CHAIN));
379 assertEquals("Number of Rules", 2, ruleSet.getRules().size());
380 assertNotNull(ruleSet.getRuleByName("ExternalRefRuleNameRef"));
381 assertNotNull(ruleSet.getRuleByName("ExternalRefRuleNameRefRef"));
382
383 rsf.setMinimumPriority(RulePriority.HIGH);
384 ruleSet = rsf
385 .createRuleSet(createRuleSetReferenceId(REF_INTERNAL_TO_EXTERNAL_CHAIN));
386 assertEquals("Number of Rules", 1, ruleSet.getRules().size());
387 assertNotNull(ruleSet.getRuleByName("ExternalRefRuleNameRefRef"));
388 }
389
390 @Test
391 public void testOverrideMessage() throws RuleSetNotFoundException {
392 Rule r = loadFirstRule(REF_OVERRIDE_ORIGINAL_NAME);
393 assertEquals("TestMessageOverride", r.getMessage());
394 }
395
396 @Test
397 public void testOverrideMessageOneElem() throws RuleSetNotFoundException {
398 Rule r = loadFirstRule(REF_OVERRIDE_ORIGINAL_NAME_ONE_ELEM);
399 assertEquals("TestMessageOverride", r.getMessage());
400 }
401
402 @Test(expected = IllegalArgumentException.class)
403 public void testIncorrectExternalRef() throws IllegalArgumentException,
404 RuleSetNotFoundException {
405 loadFirstRule(REF_MISPELLED_XREF);
406 }
407
408 @Test
409 public void testSetPriority() throws RuleSetNotFoundException {
410 RuleSetFactory rsf = new RuleSetFactory();
411 rsf.setMinimumPriority(RulePriority.MEDIUM_HIGH);
412 assertEquals(0, rsf
413 .createRuleSet(createRuleSetReferenceId(SINGLE_RULE)).size());
414 rsf.setMinimumPriority(RulePriority.MEDIUM_LOW);
415 assertEquals(1, rsf
416 .createRuleSet(createRuleSetReferenceId(SINGLE_RULE)).size());
417 }
418
419 @Test
420 public void testLanguage() throws RuleSetNotFoundException {
421 Rule r = loadFirstRule(LANGUAGE);
422 assertEquals(LanguageRegistry.getLanguage(DummyLanguageModule.NAME), r.getLanguage());
423 }
424
425 @Test(expected = IllegalArgumentException.class)
426 public void testIncorrectLanguage() throws RuleSetNotFoundException {
427 loadFirstRule(INCORRECT_LANGUAGE);
428 }
429
430 @Test
431 public void testMinimumLanugageVersion() throws RuleSetNotFoundException {
432 Rule r = loadFirstRule(MINIMUM_LANGUAGE_VERSION);
433 assertEquals(LanguageRegistry.getLanguage(DummyLanguageModule.NAME).getVersion("1.4"), r.getMinimumLanguageVersion());
434 }
435
436 @Test(expected = IllegalArgumentException.class)
437 public void testIncorrectMinimumLanugageVersion()
438 throws RuleSetNotFoundException {
439 loadFirstRule(INCORRECT_MINIMUM_LANGUAGE_VERSION);
440 }
441
442 @Test
443 public void testMaximumLanugageVersion() throws RuleSetNotFoundException {
444 Rule r = loadFirstRule(MAXIMUM_LANGUAGE_VERSION);
445 assertEquals(LanguageRegistry.getLanguage(DummyLanguageModule.NAME).getVersion("1.7"), r.getMaximumLanguageVersion());
446 }
447
448 @Test(expected = IllegalArgumentException.class)
449 public void testIncorrectMaximumLanugageVersion()
450 throws RuleSetNotFoundException {
451 loadFirstRule(INCORRECT_MAXIMUM_LANGUAGE_VERSION);
452 }
453
454 @Test(expected = IllegalArgumentException.class)
455 public void testInvertedMinimumMaximumLanugageVersions()
456 throws RuleSetNotFoundException {
457 loadFirstRule(INVERTED_MINIMUM_MAXIMUM_LANGUAGE_VERSIONS);
458 }
459
460 @Test
461 public void testDirectDeprecatedRule() throws RuleSetNotFoundException {
462 Rule r = loadFirstRule(DIRECT_DEPRECATED_RULE);
463 assertNotNull("Direct Deprecated Rule", r);
464 }
465
466 @Test
467 public void testReferenceToDeprecatedRule() throws RuleSetNotFoundException {
468 Rule r = loadFirstRule(REFERENCE_TO_DEPRECATED_RULE);
469 assertNotNull("Reference to Deprecated Rule", r);
470 assertTrue("Rule Reference", r instanceof RuleReference);
471 assertFalse("Not deprecated", r.isDeprecated());
472 assertTrue("Original Rule Deprecated", ((RuleReference) r).getRule()
473 .isDeprecated());
474 assertEquals("Rule name", r.getName(), DEPRECATED_RULE_NAME);
475 }
476
477 @Test
478 public void testRuleSetReferenceWithDeprecatedRule()
479 throws RuleSetNotFoundException {
480 RuleSet ruleSet = loadRuleSet(REFERENCE_TO_RULESET_WITH_DEPRECATED_RULE);
481 assertNotNull("RuleSet", ruleSet);
482 assertFalse("RuleSet empty", ruleSet.getRules().isEmpty());
483
484
485 Rule r = ruleSet.getRuleByName(DEPRECATED_RULE_NAME);
486 assertNull("Deprecated Rule Reference", r);
487 for (Rule rule : ruleSet.getRules()) {
488 assertFalse("Rule not deprecated", rule.isDeprecated());
489 }
490 }
491
492 @Test
493 public void testExternalReferences() throws RuleSetNotFoundException {
494 RuleSet rs = loadRuleSet(EXTERNAL_REFERENCE_RULE_SET);
495 assertEquals(1, rs.size());
496 assertEquals(MockRule.class.getName(), rs.getRuleByName(
497 "MockRule").getRuleClass());
498 }
499
500 @Test
501 public void testIncludeExcludePatterns() throws RuleSetNotFoundException {
502 RuleSet ruleSet = loadRuleSet(INCLUDE_EXCLUDE_RULESET);
503
504 assertNotNull("Include patterns", ruleSet.getIncludePatterns());
505 assertEquals("Include patterns size", 2, ruleSet.getIncludePatterns()
506 .size());
507 assertEquals("Include pattern #1", "include1", ruleSet
508 .getIncludePatterns().get(0));
509 assertEquals("Include pattern #2", "include2", ruleSet
510 .getIncludePatterns().get(1));
511
512 assertNotNull("Exclude patterns", ruleSet.getExcludePatterns());
513 assertEquals("Exclude patterns size", 3, ruleSet.getExcludePatterns()
514 .size());
515 assertEquals("Exclude pattern #1", "exclude1", ruleSet
516 .getExcludePatterns().get(0));
517 assertEquals("Exclude pattern #2", "exclude2", ruleSet
518 .getExcludePatterns().get(1));
519 assertEquals("Exclude pattern #3", "exclude3", ruleSet
520 .getExcludePatterns().get(2));
521 }
522
523
524
525
526
527 @Test(expected = RuntimeException.class)
528 public void testBug1202() throws Exception {
529 RuleSetReferenceId ref = createRuleSetReferenceId("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
530 "<ruleset>\n" +
531 " <rule ref=\"net.sourceforge.pmd.rules.XPathRule\">\n" +
532 " <priority>1</priority>\n" +
533 " <properties>\n" +
534 " <property name=\"xpath\" value=\"//TypeDeclaration\" />\n" +
535 " <property name=\"message\" value=\"Foo\" />\n" +
536 " </properties>\n" +
537 " </rule>\n" +
538 "</ruleset>\n");
539 RuleSetFactory ruleSetFactory = new RuleSetFactory();
540 ruleSetFactory.createRuleSet(ref);
541 }
542
543
544
545
546
547 @Test
548 public void testEmptyRuleSetFile() throws Exception {
549 RuleSetReferenceId ref = createRuleSetReferenceId("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
550 "\n" +
551 "<ruleset name=\"Custom ruleset\" xmlns=\"http://pmd.sourceforge.net/ruleset/2.0.0\"\n" +
552 " xmlns:xsi=\"http:www.w3.org/2001/XMLSchema-instance\"\n" +
553 " xsi:schemaLocation=\"http://pmd.sourceforge.net/ruleset/2.0.0 http://pmd.sourceforge.net/ruleset_2_0_0.xsd\">\n" +
554 " <description>PMD Ruleset.</description>\n" +
555 "\n" +
556 " <exclude-pattern>.*Test.*</exclude-pattern>\n" +
557 "\n" +
558 "</ruleset>\n");
559 RuleSetFactory ruleSetFactory = new RuleSetFactory();
560 RuleSet ruleset = ruleSetFactory.createRuleSet(ref);
561 assertEquals(0, ruleset.getRules().size());
562 }
563
564
565
566
567
568 @Test(expected = IllegalArgumentException.class)
569 public void testWrongRuleNameReferenced() throws Exception {
570 RuleSetReferenceId ref = createRuleSetReferenceId("<?xml version=\"1.0\"?>\n" +
571 "<ruleset name=\"Custom ruleset for tests\"\n" +
572 " xmlns=\"http://pmd.sourceforge.net/ruleset/2.0.0\"\n" +
573 " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n" +
574 " xsi:schemaLocation=\"http://pmd.sourceforge.net/ruleset/2.0.0 http://pmd.sourceforge.net/ruleset_2_0_0.xsd\">\n" +
575 " <description>Custom ruleset for tests</description>\n" +
576 " <rule ref=\"net/sourceforge/pmd/TestRuleset1.xml/ThisRuleDoesNotExist\"/>\n" +
577 "</ruleset>\n");
578 RuleSetFactory ruleSetFactory = new RuleSetFactory();
579 ruleSetFactory.createRuleSet(ref);
580 }
581
582
583
584
585
586
587 @Test
588 public void testRuleReferenceWithNameOverridden() throws Exception {
589 RuleSetReferenceId ref = createRuleSetReferenceId("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
590 "<ruleset xmlns=\"http://pmd.sourceforge.net/ruleset/2.0.0\"\n" +
591 " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n" +
592 " name=\"pmd-eclipse\"\n" +
593 " xsi:schemaLocation=\"http://pmd.sourceforge.net/ruleset/2.0.0 http://pmd.sourceforge.net/ruleset_2_0_0.xsd\">\n" +
594 " <description>PMD Plugin preferences rule set</description>\n" +
595 "\n" +
596 "<rule name=\"OverriddenDummyBasicMockRule\"\n" +
597 " ref=\"rulesets/dummy/basic.xml/DummyBasicMockRule\">\n" +
598 "</rule>\n" +
599 "\n" +
600 "</ruleset>");
601 RuleSetFactory ruleSetFactory = new RuleSetFactory();
602 RuleSet rs = ruleSetFactory.createRuleSet(ref);
603
604 Rule r = rs.getRules().toArray(new Rule[1])[0];
605 assertEquals("OverriddenDummyBasicMockRule", r.getName());
606 RuleReference ruleRef = (RuleReference)r;
607 assertEquals("DummyBasicMockRule", ruleRef.getRule().getName());
608 }
609
610
611
612
613
614 @Test(expected = IllegalArgumentException.class)
615 public void testWrongRuleNameExcluded() throws Exception {
616 RuleSetReferenceId ref = createRuleSetReferenceId("<?xml version=\"1.0\"?>\n" +
617 "<ruleset name=\"Custom ruleset for tests\"\n" +
618 " xmlns=\"http://pmd.sourceforge.net/ruleset/2.0.0\"\n" +
619 " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n" +
620 " xsi:schemaLocation=\"http://pmd.sourceforge.net/ruleset/2.0.0 http://pmd.sourceforge.net/ruleset_2_0_0.xsd\">\n" +
621 " <description>Custom ruleset for tests</description>\n" +
622 " <rule ref=\"net/sourceforge/pmd/TestRuleset1.xml\">\n" +
623 " <exclude name=\"ThisRuleDoesNotExist\"/>\n" +
624 " </rule>\n" +
625 "</ruleset>\n");
626 RuleSetFactory ruleSetFactory = new RuleSetFactory();
627 ruleSetFactory.createRuleSet(ref);
628 }
629
630 private static final String REF_OVERRIDE_ORIGINAL_NAME = "<?xml version=\"1.0\"?>"
631 + PMD.EOL
632 + "<ruleset name=\"test\">"
633 + PMD.EOL
634 + " <description>testdesc</description>"
635 + PMD.EOL
636 + " <rule "
637 + PMD.EOL
638 + " ref=\"net/sourceforge/pmd/TestRuleset1.xml/MockRule1\" message=\"TestMessageOverride\"> "
639 + PMD.EOL + " </rule>" + PMD.EOL + "</ruleset>";
640
641 private static final String REF_MISPELLED_XREF = "<?xml version=\"1.0\"?>"
642 + PMD.EOL + "<ruleset name=\"test\">" + PMD.EOL
643 + " <description>testdesc</description>" + PMD.EOL + " <rule "
644 + PMD.EOL
645 + " ref=\"net/sourceforge/pmd/TestRuleset1.xml/FooMockRule1\"> "
646 + PMD.EOL + " </rule>" + PMD.EOL + "</ruleset>";
647
648 private static final String REF_OVERRIDE_ORIGINAL_NAME_ONE_ELEM = "<?xml version=\"1.0\"?>"
649 + PMD.EOL
650 + "<ruleset name=\"test\">"
651 + PMD.EOL
652 + " <description>testdesc</description>"
653 + PMD.EOL
654 + " <rule ref=\"net/sourceforge/pmd/TestRuleset1.xml/MockRule1\" message=\"TestMessageOverride\"/> "
655 + PMD.EOL + "</ruleset>";
656
657 private static final String REF_OVERRIDE = "<?xml version=\"1.0\"?>"
658 + PMD.EOL
659 + "<ruleset name=\"test\">"
660 + PMD.EOL
661 + " <description>testdesc</description>"
662 + PMD.EOL
663 + " <rule "
664 + PMD.EOL
665 + " ref=\"net/sourceforge/pmd/TestRuleset1.xml/MockRule1\" "
666 + PMD.EOL
667 + " name=\"TestNameOverride\" "
668 + PMD.EOL
669 + " message=\"Test message override\"> "
670 + PMD.EOL
671 + " <description>Test description override</description>"
672 + PMD.EOL
673 + " <example>Test example override</example>"
674 + PMD.EOL
675 + " <priority>3</priority>"
676 + PMD.EOL
677 + " <properties>"
678 + PMD.EOL
679 + " <property name=\"test2\" description=\"test2\" type=\"String\" value=\"override2\"/>"
680 + PMD.EOL
681 + " <property name=\"test3\" description=\"test3\" type=\"String\"><value>override3</value></property>"
682 + PMD.EOL
683 + " <property name=\"test4\" description=\"test4\" type=\"String\" value=\"new property\"/>"
684 + PMD.EOL + " </properties>" + PMD.EOL + " </rule>" + PMD.EOL
685 + "</ruleset>";
686
687 private static final String REF_INTERNAL_TO_INTERNAL = "<?xml version=\"1.0\"?>"
688 + PMD.EOL
689 + "<ruleset name=\"test\">"
690 + PMD.EOL
691 + " <description>testdesc</description>"
692 + PMD.EOL
693 + "<rule "
694 + PMD.EOL
695 + "name=\"MockRuleName\" "
696 + PMD.EOL
697 + "message=\"avoid the mock rule\" "
698 + PMD.EOL
699 + "class=\"net.sourceforge.pmd.lang.rule.MockRule\">"
700 + PMD.EOL
701 + "</rule>"
702 + " <rule ref=\"MockRuleName\" name=\"MockRuleNameRef\"/> "
703 + PMD.EOL + "</ruleset>";
704
705 private static final String REF_INTERNAL_TO_INTERNAL_CHAIN = "<?xml version=\"1.0\"?>"
706 + PMD.EOL
707 + "<ruleset name=\"test\">"
708 + PMD.EOL
709 + " <description>testdesc</description>"
710 + PMD.EOL
711 + "<rule "
712 + PMD.EOL
713 + "name=\"MockRuleName\" "
714 + PMD.EOL
715 + "message=\"avoid the mock rule\" "
716 + PMD.EOL
717 + "class=\"net.sourceforge.pmd.lang.rule.MockRule\">"
718 + PMD.EOL
719 + "</rule>"
720 + " <rule ref=\"MockRuleName\" name=\"MockRuleNameRef\"><priority>2</priority></rule> "
721 + PMD.EOL
722 + " <rule ref=\"MockRuleNameRef\" name=\"MockRuleNameRefRef\"><priority>1</priority></rule> "
723 + PMD.EOL + "</ruleset>";
724
725 private static final String REF_INTERNAL_TO_EXTERNAL = "<?xml version=\"1.0\"?>"
726 + PMD.EOL
727 + "<ruleset name=\"test\">"
728 + PMD.EOL
729 + " <description>testdesc</description>"
730 + PMD.EOL
731 + "<rule "
732 + PMD.EOL
733 + "name=\"ExternalRefRuleName\" "
734 + PMD.EOL
735 + "ref=\"net/sourceforge/pmd/TestRuleset1.xml/MockRule1\"/>"
736 + PMD.EOL
737 + " <rule ref=\"ExternalRefRuleName\" name=\"ExternalRefRuleNameRef\"/> "
738 + PMD.EOL + "</ruleset>";
739
740 private static final String REF_INTERNAL_TO_EXTERNAL_CHAIN = "<?xml version=\"1.0\"?>"
741 + PMD.EOL
742 + "<ruleset name=\"test\">"
743 + PMD.EOL
744 + " <description>testdesc</description>"
745 + PMD.EOL
746 + "<rule "
747 + PMD.EOL
748 + "name=\"ExternalRefRuleName\" "
749 + PMD.EOL
750 + "ref=\"net/sourceforge/pmd/TestRuleset2.xml/TestRule\"/>"
751 + PMD.EOL
752 + " <rule ref=\"ExternalRefRuleName\" name=\"ExternalRefRuleNameRef\"><priority>2</priority></rule> "
753 + PMD.EOL
754 + " <rule ref=\"ExternalRefRuleNameRef\" name=\"ExternalRefRuleNameRefRef\"><priority>1</priority></rule> "
755 + PMD.EOL + "</ruleset>";
756
757 private static final String EMPTY_RULESET = "<?xml version=\"1.0\"?>"
758 + PMD.EOL + "<ruleset name=\"test\">" + PMD.EOL
759 + "<description>testdesc</description>" + PMD.EOL + "</ruleset>";
760
761 private static final String SINGLE_RULE = "<?xml version=\"1.0\"?>"
762 + PMD.EOL + "<ruleset name=\"test\">" + PMD.EOL
763 + "<description>testdesc</description>" + PMD.EOL + "<rule "
764 + PMD.EOL + "name=\"MockRuleName\" " + PMD.EOL
765 + "message=\"avoid the mock rule\" " + PMD.EOL
766 + "class=\"net.sourceforge.pmd.lang.rule.MockRule\">"
767 + "<priority>3</priority>" + PMD.EOL + "</rule></ruleset>";
768
769 private static final String MULTIPLE_RULES = "<?xml version=\"1.0\"?>"
770 + PMD.EOL + "<ruleset name=\"test\">" + PMD.EOL
771 + "<description>testdesc</description>" + PMD.EOL
772 + "<rule name=\"MockRuleName1\" " + PMD.EOL
773 + "message=\"avoid the mock rule\" " + PMD.EOL
774 + "class=\"net.sourceforge.pmd.lang.rule.MockRule\">" + PMD.EOL
775 + "</rule>" + PMD.EOL + "<rule name=\"MockRuleName2\" " + PMD.EOL
776 + "message=\"avoid the mock rule\" " + PMD.EOL
777 + "class=\"net.sourceforge.pmd.lang.rule.MockRule\">" + PMD.EOL
778 + "</rule></ruleset>";
779
780 private static final String PROPERTIES = "<?xml version=\"1.0\"?>"
781 + PMD.EOL
782 + "<ruleset name=\"test\">"
783 + PMD.EOL
784 + "<description>testdesc</description>"
785 + PMD.EOL
786 + "<rule name=\"MockRuleName\" "
787 + PMD.EOL
788 + "message=\"avoid the mock rule\" "
789 + PMD.EOL
790 + "class=\"net.sourceforge.pmd.lang.rule.MockRule\">"
791 + PMD.EOL
792 + "<description>testdesc2</description>"
793 + PMD.EOL
794 + "<properties>"
795 + PMD.EOL
796 + "<property name=\"fooBoolean\" description=\"test\" type=\"Boolean\" value=\"true\" />"
797 + PMD.EOL
798 + "<property name=\"fooChar\" description=\"test\" type=\"Character\" value=\"B\" />"
799 + PMD.EOL
800 + "<property name=\"fooInt\" description=\"test\" type=\"Integer\" min=\"1\" max=\"10\" value=\"3\" />"
801 + PMD.EOL
802 + "<property name=\"fooFloat\" description=\"test\" type=\"Float\" min=\"1.0\" max=\"1.0\" value=\"1.0\" />"
803 + PMD.EOL
804 + "<property name=\"fooDouble\" description=\"test\" type=\"Double\" min=\"1.0\" max=\"9.0\" value=\"3.0\" />"
805 + PMD.EOL
806 + "<property name=\"fooString\" description=\"test\" type=\"String\" value=\"bar\" />"
807 + PMD.EOL + "</properties>" + PMD.EOL + "</rule></ruleset>";
808
809 private static final String XPATH = "<?xml version=\"1.0\"?>" + PMD.EOL
810 + "<ruleset name=\"test\">" + PMD.EOL
811 + "<description>testdesc</description>" + PMD.EOL
812 + "<rule name=\"MockRuleName\" " + PMD.EOL
813 + "message=\"avoid the mock rule\" " + PMD.EOL
814 + "class=\"net.sourceforge.pmd.lang.rule.MockRule\">"
815 + "<priority>3</priority>" + PMD.EOL + PMD.EOL
816 + "<description>testdesc2</description>" + PMD.EOL + "<properties>"
817 + PMD.EOL
818 + "<property name=\"xpath\" description=\"test\" type=\"String\">"
819 + PMD.EOL + "<value>" + PMD.EOL + "<![CDATA[ //Block ]]>" + PMD.EOL
820 + "</value>" + PMD.EOL + "</property>" + PMD.EOL + "</properties>"
821 + PMD.EOL + "</rule></ruleset>";
822
823 private static final String PRIORITY = "<?xml version=\"1.0\"?>" + PMD.EOL
824 + "<ruleset name=\"test\">" + PMD.EOL
825 + "<description>testdesc</description>" + PMD.EOL + "<rule "
826 + PMD.EOL + "name=\"MockRuleName\" " + PMD.EOL
827 + "message=\"avoid the mock rule\" " + PMD.EOL
828 + "class=\"net.sourceforge.pmd.lang.rule.MockRule\">"
829 + "<priority>3</priority>" + PMD.EOL + "</rule></ruleset>";
830
831 private static final String LANGUAGE = "<?xml version=\"1.0\"?>"
832 + PMD.EOL
833 + "<ruleset name=\"test\">"
834 + PMD.EOL
835 + "<description>testdesc</description>"
836 + PMD.EOL
837 + "<rule "
838 + PMD.EOL
839 + "name=\"MockRuleName\" "
840 + PMD.EOL
841 + "message=\"avoid the mock rule\" "
842 + PMD.EOL
843 + "class=\"net.sourceforge.pmd.lang.rule.MockRule\" language=\"dummy\">"
844 + PMD.EOL + "</rule></ruleset>";
845
846 private static final String INCORRECT_LANGUAGE = "<?xml version=\"1.0\"?>"
847 + PMD.EOL + "<ruleset name=\"test\">" + PMD.EOL
848 + "<description>testdesc</description>" + PMD.EOL + "<rule "
849 + PMD.EOL + "name=\"MockRuleName\" " + PMD.EOL
850 + "message=\"avoid the mock rule\" " + PMD.EOL
851 + "class=\"net.sourceforge.pmd.lang.rule.MockRule\"" + PMD.EOL
852 + " language=\"bogus\">" + PMD.EOL + "</rule></ruleset>";
853
854 private static final String MINIMUM_LANGUAGE_VERSION = "<?xml version=\"1.0\"?>"
855 + PMD.EOL
856 + "<ruleset name=\"test\">"
857 + PMD.EOL
858 + "<description>testdesc</description>"
859 + PMD.EOL
860 + "<rule "
861 + PMD.EOL
862 + "name=\"MockRuleName\" "
863 + PMD.EOL
864 + "message=\"avoid the mock rule\" "
865 + PMD.EOL
866 + "class=\"net.sourceforge.pmd.lang.rule.MockRule\""
867 + PMD.EOL
868 + " language=\"dummy\""
869 + PMD.EOL
870 + " minimumLanguageVersion=\"1.4\">"
871 + PMD.EOL
872 + "</rule></ruleset>";
873
874 private static final String INCORRECT_MINIMUM_LANGUAGE_VERSION = "<?xml version=\"1.0\"?>"
875 + PMD.EOL
876 + "<ruleset name=\"test\">"
877 + PMD.EOL
878 + "<description>testdesc</description>"
879 + PMD.EOL
880 + "<rule "
881 + PMD.EOL
882 + "name=\"MockRuleName\" "
883 + PMD.EOL
884 + "message=\"avoid the mock rule\" "
885 + PMD.EOL
886 + "class=\"net.sourceforge.pmd.lang.rule.MockRule\""
887 + PMD.EOL
888 + " language=\"dummy\""
889 + PMD.EOL
890 + " minimumLanguageVersion=\"bogus\">"
891 + PMD.EOL
892 + "</rule></ruleset>";
893
894 private static final String MAXIMUM_LANGUAGE_VERSION = "<?xml version=\"1.0\"?>"
895 + PMD.EOL
896 + "<ruleset name=\"test\">"
897 + PMD.EOL
898 + "<description>testdesc</description>"
899 + PMD.EOL
900 + "<rule "
901 + PMD.EOL
902 + "name=\"MockRuleName\" "
903 + PMD.EOL
904 + "message=\"avoid the mock rule\" "
905 + PMD.EOL
906 + "class=\"net.sourceforge.pmd.lang.rule.MockRule\""
907 + PMD.EOL
908 + " language=\"dummy\""
909 + PMD.EOL
910 + " maximumLanguageVersion=\"1.7\">"
911 + PMD.EOL
912 + "</rule></ruleset>";
913
914 private static final String INCORRECT_MAXIMUM_LANGUAGE_VERSION = "<?xml version=\"1.0\"?>"
915 + PMD.EOL
916 + "<ruleset name=\"test\">"
917 + PMD.EOL
918 + "<description>testdesc</description>"
919 + PMD.EOL
920 + "<rule "
921 + PMD.EOL
922 + "name=\"MockRuleName\" "
923 + PMD.EOL
924 + "message=\"avoid the mock rule\" "
925 + PMD.EOL
926 + "class=\"net.sourceforge.pmd.lang.rule.MockRule\""
927 + PMD.EOL
928 + " language=\"dummy\""
929 + PMD.EOL
930 + " maximumLanguageVersion=\"bogus\">"
931 + PMD.EOL
932 + "</rule></ruleset>";
933
934 private static final String INVERTED_MINIMUM_MAXIMUM_LANGUAGE_VERSIONS = "<?xml version=\"1.0\"?>"
935 + PMD.EOL
936 + "<ruleset name=\"test\">"
937 + PMD.EOL
938 + "<description>testdesc</description>"
939 + PMD.EOL
940 + "<rule "
941 + PMD.EOL
942 + "name=\"MockRuleName\" "
943 + PMD.EOL
944 + "message=\"avoid the mock rule\" "
945 + PMD.EOL
946 + "class=\"net.sourceforge.pmd.lang.rule.MockRule\" "
947 + PMD.EOL
948 + "language=\"dummy\""
949 + PMD.EOL
950 + " minimumLanguageVersion=\"1.7\""
951 + PMD.EOL
952 + "maximumLanguageVersion=\"1.4\">"
953 + PMD.EOL
954 + "</rule></ruleset>";
955
956 private static final String DIRECT_DEPRECATED_RULE = "<?xml version=\"1.0\"?>"
957 + PMD.EOL
958 + "<ruleset name=\"test\">"
959 + PMD.EOL
960 + "<description>testdesc</description>"
961 + PMD.EOL
962 + "<rule "
963 + PMD.EOL
964 + "name=\"MockRuleName\" "
965 + PMD.EOL
966 + "message=\"avoid the mock rule\" "
967 + PMD.EOL
968 + "class=\"net.sourceforge.pmd.lang.rule.MockRule\" deprecated=\"true\">"
969 + PMD.EOL + "</rule></ruleset>";
970
971
972
973 private static final String DEPRECATED_RULE_RULESET_NAME = "net/sourceforge/pmd/TestRuleset1.xml";
974
975
976
977 private static final String DEPRECATED_RULE_NAME = "MockRule3";
978
979 private static final String REFERENCE_TO_DEPRECATED_RULE = "<?xml version=\"1.0\"?>"
980 + PMD.EOL
981 + "<ruleset name=\"test\">"
982 + PMD.EOL
983 + "<description>testdesc</description>"
984 + PMD.EOL
985 + "<rule "
986 + PMD.EOL
987 + "ref=\""
988 + DEPRECATED_RULE_RULESET_NAME
989 + "/"
990 + DEPRECATED_RULE_NAME + "\">" + PMD.EOL + "</rule></ruleset>";
991
992 private static final String REFERENCE_TO_RULESET_WITH_DEPRECATED_RULE = "<?xml version=\"1.0\"?>"
993 + PMD.EOL
994 + "<ruleset name=\"test\">"
995 + PMD.EOL
996 + "<description>testdesc</description>"
997 + PMD.EOL
998 + "<rule "
999 + PMD.EOL
1000 + "ref=\""
1001 + DEPRECATED_RULE_RULESET_NAME
1002 + "\">"
1003 + PMD.EOL + "</rule></ruleset>";
1004
1005 private static final String DFA = "<?xml version=\"1.0\"?>" + PMD.EOL
1006 + "<ruleset name=\"test\">" + PMD.EOL
1007 + "<description>testdesc</description>" + PMD.EOL + "<rule "
1008 + PMD.EOL + "name=\"MockRuleName\" " + PMD.EOL
1009 + "message=\"avoid the mock rule\" " + PMD.EOL + "dfa=\"true\" "
1010 + PMD.EOL + "class=\"net.sourceforge.pmd.lang.rule.MockRule\">"
1011 + "<priority>3</priority>" + PMD.EOL + "</rule></ruleset>";
1012
1013 private static final String INCLUDE_EXCLUDE_RULESET = "<?xml version=\"1.0\"?>"
1014 + PMD.EOL
1015 + "<ruleset name=\"test\">"
1016 + PMD.EOL
1017 + "<description>testdesc</description>"
1018 + PMD.EOL
1019 + "<include-pattern>include1</include-pattern>"
1020 + PMD.EOL
1021 + "<include-pattern>include2</include-pattern>"
1022 + PMD.EOL
1023 + "<exclude-pattern>exclude1</exclude-pattern>"
1024 + PMD.EOL
1025 + "<exclude-pattern>exclude2</exclude-pattern>"
1026 + PMD.EOL
1027 + "<exclude-pattern>exclude3</exclude-pattern>"
1028 + PMD.EOL
1029 + "</ruleset>";
1030
1031 private static final String EXTERNAL_REFERENCE_RULE_SET = "<?xml version=\"1.0\"?>"
1032 + PMD.EOL
1033 + "<ruleset name=\"test\">"
1034 + PMD.EOL
1035 + "<description>testdesc</description>"
1036 + PMD.EOL
1037 + "<rule ref=\"net/sourceforge/pmd/external-reference-ruleset.xml/MockRule\"/>"
1038 + PMD.EOL + "</ruleset>";
1039
1040 private Rule loadFirstRule(String ruleSetXml)
1041 throws RuleSetNotFoundException {
1042 RuleSet rs = loadRuleSet(ruleSetXml);
1043 return rs.getRules().iterator().next();
1044 }
1045
1046 private RuleSet loadRuleSet(String ruleSetXml)
1047 throws RuleSetNotFoundException {
1048 RuleSetFactory rsf = new RuleSetFactory();
1049 return rsf.createRuleSet(createRuleSetReferenceId(ruleSetXml));
1050 }
1051
1052 private static RuleSetReferenceId createRuleSetReferenceId(final String ruleSetXml) {
1053 return new RuleSetReferenceId(null) {
1054 @Override
1055 public InputStream getInputStream(ClassLoader classLoader) throws RuleSetNotFoundException {
1056 try {
1057 return new ByteArrayInputStream(ruleSetXml.getBytes("UTF-8"));
1058 } catch (UnsupportedEncodingException e) {
1059 return null;
1060 }
1061 }
1062 };
1063 }
1064 }