View Javadoc
1   /**
2    * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
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  	    // added by referencing a complete ruleset (TestRuleset1.xml)
62  	    assertNotNull(rs.getRuleByName("MockRule1"));
63  	    assertNotNull(rs.getRuleByName("MockRule2"));
64  	    assertNotNull(rs.getRuleByName("MockRule3"));
65          assertNotNull(rs.getRuleByName("TestRuleRef"));
66  
67  	    // added by specific reference
68  	    assertNotNull(rs.getRuleByName("TestRule"));
69  	    // this is from TestRuleset2.xml, but not referenced
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  	    // assert that MockRule2 is only once added to the ruleset, so that it really
79  	    // overwrites the configuration inherited from TestRuleset1.xml
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  	    // included from TestRuleset3.xml
89  	    assertNotNull(rs.getRuleByName("Ruleset3Rule2"));
90  	    // excluded from TestRuleset3.xml
91  	    assertNull(rs.getRuleByName("Ruleset3Rule1"));
92  
93  	    // overridden to 5
94  	    Rule ruleset4Rule1 = rs.getRuleByName("Ruleset4Rule1");
95  	    assertNotNull(ruleset4Rule1);
96  	    assertEquals(5, ruleset4Rule1.getPriority().getPriority());
97  	    assertEquals(1, countRule(rs, "Ruleset4Rule1"));
98  	    // priority overridden for whole TestRuleset4 group
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 		// No deprecated Rules should be loaded when loading an entire RuleSet
484 		// by reference.
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      * Rule reference can't be resolved - ref is used instead of class and the class is old (pmd 4.3 and not pmd 5).
525      * @throws Exception any error
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      * See https://sourceforge.net/p/pmd/bugs/1225/
545      * @throws Exception any error
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      * See https://sourceforge.net/p/pmd/bugs/1231/
566      * @throws Exception any error
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      * Unit test for #1312
584      * see https://sourceforge.net/p/pmd/bugs/1312/
585      * @throws Exception any error
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      * See https://sourceforge.net/p/pmd/bugs/1231/
612      * @throws Exception any error
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 	// Note: Update this RuleSet name to a different RuleSet with deprecated
972 	// Rules when the Rules are finally removed.
973 	private static final String DEPRECATED_RULE_RULESET_NAME = "net/sourceforge/pmd/TestRuleset1.xml";
974 
975 	// Note: Update this Rule name to a different deprecated Rule when the one
976 	// listed here is finally removed.
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 }