From: Fabrice Bellingard <fabrice.bellingard@sonarsource.com>
Date: Mon, 3 Dec 2012 10:08:19 +0000 (+0100)
Subject: Revert SONAR-3885 code
X-Git-Tag: 3.4~209
X-Git-Url: https://source.dussan.org/?a=commitdiff_plain;h=7c48d7d02be54043f6ec236abf422fe265fc5a69;p=sonarqube.git

Revert SONAR-3885 code

This reverts commit ef9e63fa87b0a4cc943b969f972217163241869e.
This reverts commit 0ca3e750948ff947c6ab5918cb7f36c9ad0095bb.
This reverts commit b988f880e5658cb6cc733391de782ff539cd527b.
This reverts commit ab832caa3878603fc087749732def51e1f4ffacc.
This reverts commit 5d308f5d402522b2a387e30292187d71a3724ba8.
This reverts commit 123ef89aa488f906363d5fba90951be7d430756a.
This reverts commit 14de16c62104cff7d8cb0a272b1f3abb29458f6e.
---

diff --git a/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/batch/ExcludedResourceFilter.java b/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/batch/ExcludedResourceFilter.java
index 8a71fb83425..46516ff4d8a 100644
--- a/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/batch/ExcludedResourceFilter.java
+++ b/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/batch/ExcludedResourceFilter.java
@@ -35,18 +35,13 @@ public class ExcludedResourceFilter implements ResourceFilter {
   }
 
   public boolean isIgnored(Resource resource) {
-    boolean isTest = ResourceUtils.isUnitTestClass(resource);
-
-    String[] exclusions = isTest ? project.getTestExclusionPatterns() : project.getExclusionPatterns();
-    for (String exclusion : exclusions) {
-      if (resource.matchFilePattern(exclusion)) {
-        return true;
-      }
+    String[] patterns = ResourceUtils.isUnitTestClass(resource) ? project.getTestExclusionPatterns() : project.getExclusionPatterns();
+    if (patterns == null) {
+      return false;
     }
 
-    String[] inclusions = isTest ? project.getTestInclusionPatterns() : project.getInclusionPatterns();
-    for (String inclusion : inclusions) {
-      if (!resource.matchFilePattern(inclusion)) {
+    for (String pattern : patterns) {
+      if (resource.matchFilePattern(pattern)) {
         return true;
       }
     }
diff --git a/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/batch/ProjectFileSystemLogger.java b/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/batch/ProjectFileSystemLogger.java
index d28b0ba002a..3364e99b8f6 100644
--- a/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/batch/ProjectFileSystemLogger.java
+++ b/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/batch/ProjectFileSystemLogger.java
@@ -33,9 +33,7 @@ public class ProjectFileSystemLogger extends Initializer {
 
   @Override
   public void execute(Project project) {
-    logExclusionPatterns("Included sources: {}", project.getInclusionPatterns());
     logExclusionPatterns("Excluded sources: {}", project.getExclusionPatterns());
-    logExclusionPatterns("Included tests: {}", project.getTestExclusionPatterns());
     logExclusionPatterns("Excluded tests: {}", project.getTestExclusionPatterns());
 
     ProjectFileSystem projectFileSystem = project.getFileSystem();
diff --git a/plugins/sonar-core-plugin/src/main/resources/org/sonar/l10n/core.properties b/plugins/sonar-core-plugin/src/main/resources/org/sonar/l10n/core.properties
index 092e3188251..5932b982884 100644
--- a/plugins/sonar-core-plugin/src/main/resources/org/sonar/l10n/core.properties
+++ b/plugins/sonar-core-plugin/src/main/resources/org/sonar/l10n/core.properties
@@ -659,10 +659,6 @@ category.exclusions.help=<h2>Wildcards</h2>\
      <td>?</td>\
      <td>Match a single character</td>\
    </tr>\
-   <tr class="even">\
-     <td>!</td>\
-     <td>Negates a pattern</td>\
-   </tr>\
  </table>\
  <p>Examples:</p>\
  <table class="data">\
@@ -720,17 +716,6 @@ category.exclusions.help=<h2>Wildcards</h2>\
        </ul>\
      </td>\
    </tr>\
-   <tr class="even">\
-     <td>!**/*Test.java</td>\
-     <td>matches all <code>.java</code> files whose name doesn't end with <code>Test</code></td>\
-     <td>\
-       <ul>\
-         <li>Foo.java</li>\
-         <li>foo/Bar.java</li>\
-         <li>foo/bar/Baz.java</li>\
-       </ul>\
-     </td>\
-   </tr>\
  </table>
 
 property.error.notBoolean=Valid options are "true" and "false"
diff --git a/plugins/sonar-core-plugin/src/test/java/org/sonar/plugins/core/batch/ExcludedResourceFilterTest.java b/plugins/sonar-core-plugin/src/test/java/org/sonar/plugins/core/batch/ExcludedResourceFilterTest.java
index bdd1bb7643f..1b9612ae750 100644
--- a/plugins/sonar-core-plugin/src/test/java/org/sonar/plugins/core/batch/ExcludedResourceFilterTest.java
+++ b/plugins/sonar-core-plugin/src/test/java/org/sonar/plugins/core/batch/ExcludedResourceFilterTest.java
@@ -26,76 +26,55 @@ import org.sonar.api.resources.Project;
 import org.sonar.api.resources.Qualifiers;
 import org.sonar.api.resources.Resource;
 
-import static org.fest.assertions.Assertions.assertThat;
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
 public class ExcludedResourceFilterTest {
-  Resource resource = mock(Resource.class);
 
   @Test
   public void doNotFailIfNoPatterns() {
-    Project project = new Project("foo").setConfiguration(configWithExclusions());
-
+    PropertiesConfiguration conf = new PropertiesConfiguration();
+    Project project = new Project("foo").setConfiguration(conf);
     ExcludedResourceFilter filter = new ExcludedResourceFilter(project);
-
-    assertThat(filter.isIgnored(resource)).isFalse();
+    assertThat(filter.isIgnored(mock(Resource.class)), is(false));
   }
 
   @Test
   public void noPatternsMatch() {
-    Project project = new Project("foo").setConfiguration(configWithExclusions("**/foo/*.java", "**/bar/*"));
-
+    PropertiesConfiguration conf = new PropertiesConfiguration();
+    conf.setProperty(CoreProperties.PROJECT_EXCLUSIONS_PROPERTY, new String[]{"**/foo/*.java", "**/bar/*"});
+    Project project = new Project("foo").setConfiguration(conf);
     ExcludedResourceFilter filter = new ExcludedResourceFilter(project);
-
-    assertThat(filter.isIgnored(resource)).isFalse();
+    assertThat(filter.isIgnored(mock(Resource.class)), is(false));
   }
 
   @Test
   public void ignoreResourceIfMatchesPattern() {
-    when(resource.matchFilePattern("**/bar/*")).thenReturn(true);
-
-    Project project = new Project("foo").setConfiguration(configWithExclusions("**/foo/*.java", "**/bar/*"));
-    ExcludedResourceFilter filter = new ExcludedResourceFilter(project);
-
-    assertThat(filter.isIgnored(resource)).isTrue();
-  }
-
-  @Test
-  public void should_support_inclusions() {
-    Project project = new Project("foo").setConfiguration(configWithExclusions("!**/bar/*"));
+    PropertiesConfiguration conf = new PropertiesConfiguration();
+    conf.setProperty(CoreProperties.PROJECT_EXCLUSIONS_PROPERTY, new String[]{"**/foo/*.java", "**/bar/*"});
+    Project project = new Project("foo").setConfiguration(conf);
     ExcludedResourceFilter filter = new ExcludedResourceFilter(project);
 
+    Resource resource = mock(Resource.class);
     when(resource.matchFilePattern("**/bar/*")).thenReturn(true);
-    assertThat(filter.isIgnored(resource)).isFalse();
 
-    when(resource.matchFilePattern("**/bar/*")).thenReturn(false);
-    assertThat(filter.isIgnored(resource)).isTrue();
+    assertThat(filter.isIgnored(resource), is(true));
   }
 
   @Test
-  public void should_support_test_inclusions() {
-    when(resource.getQualifier()).thenReturn(Qualifiers.UNIT_TEST_FILE);
-
-    Project project = new Project("foo").setConfiguration(configWithTestExclusions("!**/bar/*"));
+  public void ignoreTestIfMatchesPattern() {
+    PropertiesConfiguration conf = new PropertiesConfiguration();
+    conf.setProperty(CoreProperties.PROJECT_TEST_EXCLUSIONS_PROPERTY, new String[]{"**/foo/*.java", "**/bar/*"});
+    Project project = new Project("foo").setConfiguration(conf);
     ExcludedResourceFilter filter = new ExcludedResourceFilter(project);
 
-    when(resource.matchFilePattern("**/bar/*")).thenReturn(true);
-    assertThat(filter.isIgnored(resource)).isFalse();
-
-    when(resource.matchFilePattern("**/bar/*")).thenReturn(false);
-    assertThat(filter.isIgnored(resource)).isTrue();
-  }
-
-  @Test
-  public void ignoreTestIfMatchesPattern() {
+    Resource resource = mock(Resource.class);
     when(resource.getQualifier()).thenReturn(Qualifiers.UNIT_TEST_FILE);
     when(resource.matchFilePattern("**/bar/*")).thenReturn(true);
 
-    Project project = new Project("foo").setConfiguration(configWithTestExclusions("**/foo/*.java", "**/bar/*"));
-    ExcludedResourceFilter filter = new ExcludedResourceFilter(project);
-
-    assertThat(filter.isIgnored(resource)).isTrue();
+    assertThat(filter.isIgnored(resource), is(true));
   }
 
   /**
@@ -103,26 +82,17 @@ public class ExcludedResourceFilterTest {
    */
   @Test
   public void doNotExcludeUnitTestFiles() {
-    when(resource.getQualifier()).thenReturn(Qualifiers.UNIT_TEST_FILE);
-    when(resource.matchFilePattern("**/bar/*")).thenReturn(true);
-
-    Project project = new Project("foo").setConfiguration(configWithExclusions("**/foo/*.java", "**/bar/*"));
+    PropertiesConfiguration conf = new PropertiesConfiguration();
+    conf.setProperty(CoreProperties.PROJECT_EXCLUSIONS_PROPERTY, new String[]{"**/foo/*.java", "**/bar/*"});
+    Project project = new Project("foo").setConfiguration(conf);
     ExcludedResourceFilter filter = new ExcludedResourceFilter(project);
 
-    assertThat(filter.isIgnored(resource)).isFalse();
-  }
+    Resource unitTest = mock(Resource.class);
+    when(unitTest.getQualifier()).thenReturn(Qualifiers.UNIT_TEST_FILE);
 
-  static PropertiesConfiguration configWithExclusions(String... exclusions) {
-    return config(CoreProperties.PROJECT_EXCLUSIONS_PROPERTY, exclusions);
-  }
-
-  static PropertiesConfiguration configWithTestExclusions(String... exclusions) {
-    return config(CoreProperties.PROJECT_TEST_EXCLUSIONS_PROPERTY, exclusions);
-  }
+    // match exclusion pattern
+    when(unitTest.matchFilePattern("**/bar/*")).thenReturn(true);
 
-  static PropertiesConfiguration config(String property, String... exclusions) {
-    PropertiesConfiguration config = new PropertiesConfiguration();
-    config.setProperty(property, exclusions);
-    return config;
+    assertThat(filter.isIgnored(unitTest), is(false));
   }
 }
diff --git a/plugins/sonar-findbugs-plugin/src/main/java/org/sonar/plugins/findbugs/FindbugsConfiguration.java b/plugins/sonar-findbugs-plugin/src/main/java/org/sonar/plugins/findbugs/FindbugsConfiguration.java
index 24ff073ddf9..ad24fa026ae 100644
--- a/plugins/sonar-findbugs-plugin/src/main/java/org/sonar/plugins/findbugs/FindbugsConfiguration.java
+++ b/plugins/sonar-findbugs-plugin/src/main/java/org/sonar/plugins/findbugs/FindbugsConfiguration.java
@@ -30,11 +30,15 @@ import org.sonar.api.config.Settings;
 import org.sonar.api.profiles.RulesProfile;
 import org.sonar.api.resources.Project;
 import org.sonar.api.utils.SonarException;
+import org.sonar.plugins.findbugs.xml.ClassFilter;
+import org.sonar.plugins.findbugs.xml.FindBugsFilter;
+import org.sonar.plugins.findbugs.xml.Match;
 
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
+import java.io.StringWriter;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Locale;
@@ -87,16 +91,21 @@ public class FindbugsConfiguration implements BatchExtension {
 
   @VisibleForTesting
   File saveIncludeConfigXml() throws IOException {
-    String xml = exporter.exportProfileAndInclusions(profile, project.getInclusionPatterns());
-
-    return project.getFileSystem().writeToWorkingDirectory(xml, "findbugs-include.xml");
+    StringWriter conf = new StringWriter();
+    exporter.exportProfile(profile, conf);
+    return project.getFileSystem().writeToWorkingDirectory(conf.toString(), "findbugs-include.xml");
   }
 
   @VisibleForTesting
   File saveExcludeConfigXml() throws IOException {
-    String xml = exporter.exportExclusions(project.getExclusionPatterns());
-
-    return project.getFileSystem().writeToWorkingDirectory(xml, "findbugs-exclude.xml");
+    FindBugsFilter findBugsFilter = new FindBugsFilter();
+    if (project.getExclusionPatterns() != null) {
+      for (String exclusion : project.getExclusionPatterns()) {
+        ClassFilter classFilter = new ClassFilter(FindbugsAntConverter.antToJavaRegexpConvertor(exclusion));
+        findBugsFilter.addMatch(new Match(classFilter));
+      }
+    }
+    return project.getFileSystem().writeToWorkingDirectory(findBugsFilter.toXml(), "findbugs-exclude.xml");
   }
 
   @VisibleForTesting
diff --git a/plugins/sonar-findbugs-plugin/src/main/java/org/sonar/plugins/findbugs/FindbugsProfileExporter.java b/plugins/sonar-findbugs-plugin/src/main/java/org/sonar/plugins/findbugs/FindbugsProfileExporter.java
index b261f2f203a..d735e5ebfb4 100644
--- a/plugins/sonar-findbugs-plugin/src/main/java/org/sonar/plugins/findbugs/FindbugsProfileExporter.java
+++ b/plugins/sonar-findbugs-plugin/src/main/java/org/sonar/plugins/findbugs/FindbugsProfileExporter.java
@@ -19,25 +19,25 @@
  */
 package org.sonar.plugins.findbugs;
 
+import java.io.IOException;
+import java.io.Writer;
+import java.util.List;
+
 import org.sonar.api.profiles.ProfileExporter;
 import org.sonar.api.profiles.RulesProfile;
 import org.sonar.api.resources.Java;
 import org.sonar.api.rules.ActiveRule;
 import org.sonar.api.utils.SonarException;
 import org.sonar.plugins.findbugs.xml.Bug;
-import org.sonar.plugins.findbugs.xml.ClassFilter;
 import org.sonar.plugins.findbugs.xml.FindBugsFilter;
 import org.sonar.plugins.findbugs.xml.Match;
 
-import java.io.IOException;
-import java.io.Writer;
-import java.util.List;
+import com.thoughtworks.xstream.XStream;
 
 public class FindbugsProfileExporter extends ProfileExporter {
 
   public FindbugsProfileExporter() {
     super(FindbugsConstants.REPOSITORY_KEY, FindbugsConstants.PLUGIN_NAME);
-
     setSupportedLanguages(Java.KEY);
     setMimeType("application/xml");
   }
@@ -45,44 +45,16 @@ public class FindbugsProfileExporter extends ProfileExporter {
   @Override
   public void exportProfile(RulesProfile profile, Writer writer) {
     try {
-      String xml = exportProfileAndInclusions(profile, null);
-      writer.write(xml);
+      FindBugsFilter filter = buildFindbugsFilter(profile.getActiveRulesByRepository(FindbugsConstants.REPOSITORY_KEY));
+      XStream xstream = FindBugsFilter.createXStream();
+      writer.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<!-- Generated by Sonar -->\n".concat(xstream.toXML(filter)));
     } catch (IOException e) {
-      throw new SonarException("Fail to export Findbugs profile: " + profile.getName(), e);
+      throw new SonarException("Fail to export the Findbugs profile : " + profile, e);
     }
   }
 
-  public String exportProfileAndInclusions(RulesProfile profile, String[] inclusions) {
+  protected static FindBugsFilter buildFindbugsFilter(List<ActiveRule> activeRules) {
     FindBugsFilter root = new FindBugsFilter();
-    addRules(root, profile.getActiveRulesByRepository(FindbugsConstants.REPOSITORY_KEY));
-    addPatterns(root, inclusions);
-    return toXml(root);
-  }
-
-  public String exportExclusions(String[] exclusions) {
-    FindBugsFilter root = new FindBugsFilter();
-    addPatterns(root, exclusions);
-    return toXml(root);
-  }
-
-  private static String toXml(FindBugsFilter root) {
-    return new StringBuilder()
-        .append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")
-        .append("<!-- Generated by Sonar -->\n")
-        .append(root.toXml())
-        .toString();
-  }
-
-  private static void addPatterns(FindBugsFilter root, String[] patterns) {
-    if (patterns != null) {
-      for (String pattern : patterns) {
-        ClassFilter classFilter = new ClassFilter(FindbugsAntConverter.antToJavaRegexpConvertor(pattern));
-        root.addMatch(new Match(classFilter));
-      }
-    }
-  }
-
-  protected static void addRules(FindBugsFilter root, List<ActiveRule> activeRules) {
     for (ActiveRule activeRule : activeRules) {
       if (FindbugsConstants.REPOSITORY_KEY.equals(activeRule.getRepositoryKey())) {
         Match child = new Match();
@@ -90,5 +62,6 @@ public class FindbugsProfileExporter extends ProfileExporter {
         root.addMatch(child);
       }
     }
+    return root;
   }
 }
diff --git a/plugins/sonar-findbugs-plugin/src/test/java/org/sonar/plugins/findbugs/FindbugsProfileExporterTest.java b/plugins/sonar-findbugs-plugin/src/test/java/org/sonar/plugins/findbugs/FindbugsProfileExporterTest.java
index 9cb7eb742c0..27f3545dfd4 100644
--- a/plugins/sonar-findbugs-plugin/src/test/java/org/sonar/plugins/findbugs/FindbugsProfileExporterTest.java
+++ b/plugins/sonar-findbugs-plugin/src/test/java/org/sonar/plugins/findbugs/FindbugsProfileExporterTest.java
@@ -64,19 +64,15 @@ public class FindbugsProfileExporterTest extends FindbugsTests {
 
   @Test
   public void shouldBuildOnlyOneModuleWhenNoActiveRules() {
-    FindBugsFilter filter = new FindBugsFilter();
-    FindbugsProfileExporter.addRules(filter, Collections.<ActiveRule> emptyList());
-
-    assertThat(filter.getMatchs()).isEmpty();
+    FindBugsFilter filter = FindbugsProfileExporter.buildFindbugsFilter(Collections.<ActiveRule> emptyList());
+    assertThat(filter.getMatchs()).hasSize(0);
   }
 
   @Test
   public void shouldBuildTwoModulesEvenIfSameTwoRulesActivated() {
     ActiveRule activeRule1 = anActiveRule(DLS_DEAD_LOCAL_STORE);
     ActiveRule activeRule2 = anActiveRule(SS_SHOULD_BE_STATIC);
-
-    FindBugsFilter filter = new FindBugsFilter();
-    FindbugsProfileExporter.addRules(filter, Arrays.asList(activeRule1, activeRule2));
+    FindBugsFilter filter = FindbugsProfileExporter.buildFindbugsFilter(Arrays.asList(activeRule1, activeRule2));
 
     List<Match> matches = filter.getMatchs();
     assertThat(matches).hasSize(2);
@@ -90,17 +86,14 @@ public class FindbugsProfileExporterTest extends FindbugsTests {
     ActiveRule activeRule1 = anActiveRuleFromAnotherPlugin();
     ActiveRule activeRule2 = anActiveRuleFromAnotherPlugin();
 
-    FindBugsFilter filter = new FindBugsFilter();
-    FindbugsProfileExporter.addRules(filter, Arrays.asList(activeRule1, activeRule2));
+    FindBugsFilter filter = FindbugsProfileExporter.buildFindbugsFilter(Arrays.asList(activeRule1, activeRule2));
     assertThat(filter.getMatchs()).hasSize(0);
   }
 
   @Test
   public void shouldBuildModuleWithProperties() {
     ActiveRule activeRule = anActiveRule(DLS_DEAD_LOCAL_STORE);
-
-    FindBugsFilter filter = new FindBugsFilter();
-    FindbugsProfileExporter.addRules(filter, Arrays.asList(activeRule));
+    FindBugsFilter filter = FindbugsProfileExporter.buildFindbugsFilter(Arrays.asList(activeRule));
 
     assertThat(filter.getMatchs()).hasSize(1);
     assertThat(filter.getMatchs().get(0).getBug().getPattern()).isEqualTo("DLS_DEAD_LOCAL_STORE");
diff --git a/sonar-plugin-api/src/main/java/org/sonar/api/resources/DefaultProjectFileSystem.java b/sonar-plugin-api/src/main/java/org/sonar/api/resources/DefaultProjectFileSystem.java
index 6fc144a846d..5bef696d85b 100644
--- a/sonar-plugin-api/src/main/java/org/sonar/api/resources/DefaultProjectFileSystem.java
+++ b/sonar-plugin-api/src/main/java/org/sonar/api/resources/DefaultProjectFileSystem.java
@@ -26,13 +26,7 @@ import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
 import org.apache.commons.io.FileUtils;
 import org.apache.commons.io.FilenameUtils;
-import org.apache.commons.io.filefilter.AndFileFilter;
-import org.apache.commons.io.filefilter.DelegateFileFilter;
-import org.apache.commons.io.filefilter.FileFilterUtils;
-import org.apache.commons.io.filefilter.HiddenFileFilter;
-import org.apache.commons.io.filefilter.IOFileFilter;
-import org.apache.commons.io.filefilter.SuffixFileFilter;
-import org.apache.commons.io.filefilter.TrueFileFilter;
+import org.apache.commons.io.filefilter.*;
 import org.apache.commons.lang.CharEncoding;
 import org.apache.commons.lang.StringUtils;
 import org.sonar.api.CoreProperties;
@@ -42,15 +36,10 @@ import org.sonar.api.utils.SonarException;
 import org.sonar.api.utils.WildcardPattern;
 
 import javax.annotation.Nullable;
-
 import java.io.File;
 import java.io.IOException;
 import java.nio.charset.Charset;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-import java.util.Set;
+import java.util.*;
 
 /**
  * An implementation of {@link ProjectFileSystem}.
@@ -222,15 +211,14 @@ public class DefaultProjectFileSystem implements ProjectFileSystem {
     return !testFiles(lang.getKey()).isEmpty();
   }
 
-  List<InputFile> getFiles(List<File> directories, List<File> initialFiles, String[] exclusions, String[] inclusions, boolean toto, String... langs) {
+  List<InputFile> getFiles(List<File> directories, List<File> initialFiles, String[] patterns, String... langs) {
     List<InputFile> result = Lists.newArrayList();
     if (directories == null) {
       return result;
     }
 
     IOFileFilter suffixFilter = getFileSuffixFilter(langs);
-    WildcardPattern[] exclusionPatterns = WildcardPattern.create(exclusions);
-    WildcardPattern[] inclusionPatterns = WildcardPattern.create(inclusions);
+    WildcardPattern[] exclusionPatterns = WildcardPattern.create(patterns);
 
     IOFileFilter initialFilesFilter = TrueFileFilter.INSTANCE;
     if (initialFiles != null && !initialFiles.isEmpty()) {
@@ -239,7 +227,7 @@ public class DefaultProjectFileSystem implements ProjectFileSystem {
 
     for (File dir : directories) {
       if (dir.exists()) {
-        IOFileFilter exclusionFilter = new ExclusionFilter(dir, exclusionPatterns, inclusionPatterns);
+        IOFileFilter exclusionFilter = new ExclusionFilter(dir, exclusionPatterns);
         IOFileFilter visibleFileFilter = HiddenFileFilter.VISIBLE;
         List<IOFileFilter> fileFilters = Lists.newArrayList(visibleFileFilter, suffixFilter, exclusionFilter, initialFilesFilter);
         fileFilters.addAll(this.filters);
@@ -267,14 +255,12 @@ public class DefaultProjectFileSystem implements ProjectFileSystem {
   }
 
   private static class ExclusionFilter implements IOFileFilter {
-    final File sourceDir;
-    final WildcardPattern[] exclusions;
-    final WildcardPattern[] inclusions;
+    File sourceDir;
+    WildcardPattern[] patterns;
 
-    ExclusionFilter(File sourceDir, WildcardPattern[] exclusions, WildcardPattern[] inclusions) {
+    ExclusionFilter(File sourceDir, WildcardPattern[] patterns) {
       this.sourceDir = sourceDir;
-      this.exclusions = exclusions;
-      this.inclusions = inclusions;
+      this.patterns = patterns;
     }
 
     public boolean accept(File file) {
@@ -282,13 +268,8 @@ public class DefaultProjectFileSystem implements ProjectFileSystem {
       if (relativePath == null) {
         return false;
       }
-      for (WildcardPattern exclusion : exclusions) {
-        if (exclusion.match(relativePath)) {
-          return false;
-        }
-      }
-      for (WildcardPattern inclusion : inclusions) {
-        if (!inclusion.match(relativePath)) {
+      for (WildcardPattern pattern : patterns) {
+        if (pattern.match(relativePath)) {
           return false;
         }
       }
@@ -410,14 +391,14 @@ public class DefaultProjectFileSystem implements ProjectFileSystem {
    * @since 2.6
    */
   public List<InputFile> mainFiles(String... langs) {
-    return getFiles(getSourceDirs(), getInitialSourceFiles(), project.getExclusionPatterns(), project.getInclusionPatterns(), true, langs);
+    return getFiles(getSourceDirs(), getInitialSourceFiles(), project.getExclusionPatterns(), langs);
   }
 
   /**
    * @since 2.6
    */
   public List<InputFile> testFiles(String... langs) {
-    return getFiles(getTestDirs(), getInitialTestFiles(), project.getTestExclusionPatterns(), project.getTestInclusionPatterns(), true, langs);
+    return getFiles(getTestDirs(), getInitialTestFiles(), project.getTestExclusionPatterns(), langs);
   }
 
   protected List<File> getInitialSourceFiles() {
diff --git a/sonar-plugin-api/src/main/java/org/sonar/api/resources/Project.java b/sonar-plugin-api/src/main/java/org/sonar/api/resources/Project.java
index 812eeab7d6e..a7e8c7bd326 100644
--- a/sonar-plugin-api/src/main/java/org/sonar/api/resources/Project.java
+++ b/sonar-plugin-api/src/main/java/org/sonar/api/resources/Project.java
@@ -362,7 +362,9 @@ public class Project extends Resource {
    * @since 3.3 also applies exclusions in general settings page and global exclusions.
    */
   public String[] getExclusionPatterns() {
-    return removeNegativePatterns(exclusionPatterns());
+    return trimExclusions(ImmutableList.<String> builder()
+      .add(configuration.getStringArray(CoreProperties.PROJECT_EXCLUSIONS_PROPERTY))
+      .add(configuration.getStringArray(CoreProperties.GLOBAL_EXCLUSIONS_PROPERTY)).build());
   }
 
   /**
@@ -372,34 +374,6 @@ public class Project extends Resource {
    * @since 3.3
    */
   public String[] getTestExclusionPatterns() {
-    return removeNegativePatterns(testExclusionPatterns());
-  }
-
-  /**
-   * Patterns of resource inclusion as defined in project settings page.
-   *
-   * @since 3.4
-   */
-  public String[] getInclusionPatterns() {
-    return onlyNegativePatterns(exclusionPatterns());
-  }
-
-  /**
-   * Patterns of test inclusion as defined in project settings page.
-   *
-   * @since 3.4
-   */
-  public String[] getTestInclusionPatterns() {
-    return onlyNegativePatterns(testExclusionPatterns());
-  }
-
-  private List<String> exclusionPatterns() {
-    return trimExclusions(ImmutableList.<String> builder()
-        .add(configuration.getStringArray(CoreProperties.PROJECT_EXCLUSIONS_PROPERTY))
-        .add(configuration.getStringArray(CoreProperties.GLOBAL_EXCLUSIONS_PROPERTY)).build());
-  }
-
-  private List<String> testExclusionPatterns() {
     String[] globalTestExclusions = configuration.getStringArray(CoreProperties.GLOBAL_TEST_EXCLUSIONS_PROPERTY);
     if (globalTestExclusions.length == 0) {
       globalTestExclusions = new String[] {CoreProperties.GLOBAL_TEST_EXCLUSIONS_DEFAULT};
@@ -410,33 +384,13 @@ public class Project extends Resource {
         .add(globalTestExclusions).build());
   }
 
-  private static String[] removeNegativePatterns(List<String> patterns) {
-    List<String> filtered = Lists.newArrayList();
-    for (String pattern : patterns) {
-      if (!pattern.startsWith("!")) {
-        filtered.add(pattern);
-      }
-    }
-    return filtered.toArray(new String[filtered.size()]);
-  }
-
-  private static String[] onlyNegativePatterns(List<String> patterns) {
-    List<String> filtered = Lists.newArrayList();
-    for (String pattern : patterns) {
-      if (pattern.startsWith("!")) {
-        filtered.add(pattern.substring(1));
-      }
-    }
-    return filtered.toArray(new String[filtered.size()]);
-  }
-
   // http://jira.codehaus.org/browse/SONAR-2261 - exclusion must be trimmed
-  private static List<String> trimExclusions(List<String> patterns) {
+  private static String[] trimExclusions(List<String> exclusions) {
     List<String> trimmed = Lists.newArrayList();
-    for (String pattern : patterns) {
-      trimmed.add(StringUtils.trim(pattern));
+    for (String exclusion : exclusions) {
+      trimmed.add(StringUtils.trim(exclusion));
     }
-    return trimmed;
+    return trimmed.toArray(new String[trimmed.size()]);
   }
 
   /**
diff --git a/sonar-plugin-api/src/test/java/org/sonar/api/resources/DefaultProjectFileSystemTest.java b/sonar-plugin-api/src/test/java/org/sonar/api/resources/DefaultProjectFileSystemTest.java
index 865cdfdf4aa..da456d5b0b4 100644
--- a/sonar-plugin-api/src/test/java/org/sonar/api/resources/DefaultProjectFileSystemTest.java
+++ b/sonar-plugin-api/src/test/java/org/sonar/api/resources/DefaultProjectFileSystemTest.java
@@ -23,6 +23,10 @@ import org.apache.commons.configuration.PropertiesConfiguration;
 import org.apache.commons.lang.StringUtils;
 import org.apache.commons.lang.SystemUtils;
 import org.apache.maven.project.MavenProject;
+import org.hamcrest.Description;
+import org.hamcrest.Matcher;
+import org.hamcrest.Matchers;
+import org.hamcrest.TypeSafeMatcher;
 import org.junit.Before;
 import org.junit.Test;
 import org.sonar.api.CoreProperties;
@@ -34,12 +38,15 @@ import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 
-import static org.fest.assertions.Assertions.assertThat;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.Matchers.*;
+import static org.junit.Assert.assertThat;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
 public class DefaultProjectFileSystemTest {
-  Project project;
+
+  private Project project = null;
 
   @Before
   public void before() {
@@ -51,39 +58,39 @@ public class DefaultProjectFileSystemTest {
    */
   @Test
   public void shouldReturnOnlyExistingSourceAndTestDirectories() {
-    // in this example : "src/main/java" is a file, "src/test/java" doesn't exist
+    // in this example : "src/main/java" is a file, "src/test/java" doesn't exists
     project = MavenTestUtils.loadProjectFromPom(DefaultProjectFileSystemTest.class, "nonexistent-dirs/pom.xml");
-
-    ProjectFileSystem fs = project.getFileSystem();
-
-    assertThat(fs.getSourceDirs()).isEmpty();
-    assertThat(fs.getTestDirs()).isEmpty();
+    DefaultProjectFileSystem fs = newDefaultProjectFileSystem(project);
+    assertThat(fs.getSourceDirs().size(), is(0));
+    assertThat(fs.getTestDirs().size(), is(0));
   }
 
   @Test
   public void getJavaSourceFiles() {
-    ProjectFileSystem fs = project.getFileSystem();
+    final DefaultProjectFileSystem fs = newDefaultProjectFileSystem(project);
 
-    assertThat(fs.getJavaSourceFiles()).onProperty("name").containsOnly("Whizz.java", "Bar.java");
+    assertThat(fs.getJavaSourceFiles().size(), is(2));
+    assertThat(fs.getJavaSourceFiles(), hasItem(named("Bar.java")));
+    assertThat(fs.getJavaSourceFiles(), hasItem(named("Whizz.java")));
   }
 
   @Test
   public void hasJavaSourceFiles() {
-    ProjectFileSystem fs = project.getFileSystem();
-    assertThat(fs.hasJavaSourceFiles()).isTrue();
+    final DefaultProjectFileSystem fs = newDefaultProjectFileSystem(project);
+    assertThat(fs.hasJavaSourceFiles(), is(true));
 
     PropertiesConfiguration conf = new PropertiesConfiguration();
     conf.setProperty(CoreProperties.PROJECT_EXCLUSIONS_PROPERTY, "**/*.java");
     project.setConfiguration(conf);
-
-    assertThat(fs.hasJavaSourceFiles()).isFalse();
+    assertThat(fs.hasJavaSourceFiles(), is(false));
   }
 
   @Test
   public void getTestFiles() {
-    ProjectFileSystem fs = project.getFileSystem();
+    final DefaultProjectFileSystem fs = newDefaultProjectFileSystem(project);
 
-    assertThat(fs.getTestFiles(Java.INSTANCE)).onProperty("name").containsOnly("BarTest.java");
+    assertThat(fs.getTestFiles(Java.INSTANCE).size(), is(1));
+    assertThat(fs.getTestFiles(Java.INSTANCE), hasItem(named("BarTest.java")));
   }
 
   @Test
@@ -92,9 +99,10 @@ public class DefaultProjectFileSystemTest {
     conf.setProperty(CoreProperties.PROJECT_EXCLUSIONS_PROPERTY, "**/B*.java");
     project.setConfiguration(conf);
 
-    ProjectFileSystem fs = project.getFileSystem();
+    final DefaultProjectFileSystem fs = newDefaultProjectFileSystem(project);
 
-    assertThat(fs.getJavaSourceFiles()).onProperty("name").containsOnly("Whizz.java");
+    assertThat(fs.getJavaSourceFiles().size(), is(1));
+    assertThat(fs.getJavaSourceFiles(), hasItem(named("Whizz.java")));
   }
 
   /**
@@ -106,20 +114,11 @@ public class DefaultProjectFileSystemTest {
     conf.setProperty(CoreProperties.PROJECT_EXCLUSIONS_PROPERTY, "**/*.aj");
     project.setConfiguration(conf);
 
-    ProjectFileSystem fs = project.getFileSystem();
-
-    assertThat(fs.getSourceFiles(Java.INSTANCE)).onProperty("name").containsOnly("Whizz.java", "Bar.java");
-  }
-
-  @Test
-  public void should_apply_inclusions() {
-    PropertiesConfiguration conf = new PropertiesConfiguration();
-    conf.setProperty(CoreProperties.PROJECT_EXCLUSIONS_PROPERTY, "!**/W*.*");
-    project.setConfiguration(conf);
-
-    ProjectFileSystem fs = project.getFileSystem();
+    final DefaultProjectFileSystem fs = newDefaultProjectFileSystem(project);
 
-    assertThat(fs.getSourceFiles(Java.INSTANCE)).onProperty("name").containsOnly("Whizz.java");
+    assertThat(fs.getSourceFiles(Java.INSTANCE).size(), is(2));
+    assertThat(fs.getSourceFiles(Java.INSTANCE), hasItem(named("Whizz.java")));
+    assertThat(fs.getSourceFiles(Java.INSTANCE), hasItem(named("Bar.java")));
   }
 
   @Test
@@ -128,26 +127,25 @@ public class DefaultProjectFileSystemTest {
     conf.setProperty(CoreProperties.PROJECT_EXCLUSIONS_PROPERTY, "**/B*.java");
     project.setConfiguration(conf);
 
-    ProjectFileSystem fs = project.getFileSystem();
+    final DefaultProjectFileSystem fs = newDefaultProjectFileSystem(project);
 
-    assertThat(fs.getTestFiles(Java.INSTANCE)).onProperty("name").containsOnly("BarTest.java");
+    assertThat(fs.getTestFiles(Java.INSTANCE).size(), is(1));
+    assertThat(fs.getTestFiles(Java.INSTANCE), hasItem(named("BarTest.java")));
   }
 
   @Test
   public void createSonarWorkingDirectory() {
-    ProjectFileSystem fs = project.getFileSystem();
+    DefaultProjectFileSystem fs = newDefaultProjectFileSystem(project);
     java.io.File dir = fs.getSonarWorkingDirectory();
-
-    assertThat(dir).exists();
-    assertThat(dir.listFiles()).isEmpty();
+    assertThat(dir.exists(), is(true));
+    assertThat(dir.listFiles().length, is(0));
   }
 
   @Test
   public void getJapaneseCharSet() {
     project = MavenTestUtils.loadProjectFromPom(DefaultProjectFileSystemTest.class, "japanese-project/pom.xml");
-    ProjectFileSystem fs = project.getFileSystem();
-
-    assertThat(fs.getSourceCharset().name()).isEqualTo("Shift_JIS");
+    DefaultProjectFileSystem fs = newDefaultProjectFileSystem(project);
+    assertThat(fs.getSourceCharset().name(), is("Shift_JIS"));
   }
 
   @Test
@@ -167,10 +165,9 @@ public class DefaultProjectFileSystemTest {
     }
 
     project = MavenTestUtils.loadProjectFromPom(DefaultProjectFileSystemTest.class, "sample-with-different-suffixes/pom.xml");
-    ProjectFileSystem fs = project.getFileSystem();
+    ProjectFileSystem fs = newDefaultProjectFileSystem(project);
     List<File> files = fs.getSourceFiles(new NoSuffixLanguage());
-
-    assertThat(files).hasSize(2);
+    assertThat(files.size(), is(2));
   }
 
   /**
@@ -181,10 +178,10 @@ public class DefaultProjectFileSystemTest {
     MavenProject pom = mock(MavenProject.class);
     when(pom.getBasedir()).thenReturn(new File("/project"));
     Project project = new Project("foo").setPom(pom);
-    ProjectFileSystem fs = new DefaultProjectFileSystem(project, null);
+    DefaultProjectFileSystem fs = new DefaultProjectFileSystem(project, null);
 
-    assertThat(fs.resolvePath(".").getAbsolutePath()).endsWith("project");
-    assertThat(fs.resolvePath("../project").getAbsolutePath()).endsWith("project");
+    assertThat(fs.resolvePath(".").getAbsolutePath(), endsWith("project"));
+    assertThat(fs.resolvePath("../project").getAbsolutePath(), endsWith("project"));
   }
 
   /**
@@ -196,18 +193,18 @@ public class DefaultProjectFileSystemTest {
       // hidden files/directories can not be stored in svn windows
       // On Mac/Linux it's easy, just prefix the filename by '.'
       project = MavenTestUtils.loadProjectFromPom(DefaultProjectFileSystemTest.class, "hidden-files/pom.xml");
-      ProjectFileSystem fs = project.getFileSystem();
+      ProjectFileSystem fs = newDefaultProjectFileSystem(project);
       List<File> files = fs.getSourceFiles();
-      assertThat(files).hasSize(1);
-      assertThat(files.get(0).getName()).isEqualTo("foo.sql");
+      assertThat(files.size(), is(1));
+      assertThat(files.get(0).getName(), is("foo.sql"));
     }
   }
 
   @Test
   public void shouldUseExtendedFilters() {
-    ProjectFileSystem fsWithoutFilter = project.getFileSystem();
-    assertThat(fsWithoutFilter.getSourceFiles()).hasSize(2);
-    assertThat(fsWithoutFilter.getSourceFiles()).onProperty("name").contains("Bar.java");
+    DefaultProjectFileSystem fsWithoutFilter = newDefaultProjectFileSystem(project);
+    assertThat(fsWithoutFilter.getSourceFiles().size(), is(2));
+    assertThat(fsWithoutFilter.getSourceFiles(), hasItem(named("Bar.java")));
 
     FileFilter filter = new FileFilter() {
       public boolean accept(File file) {
@@ -215,21 +212,21 @@ public class DefaultProjectFileSystemTest {
       }
     };
     DefaultProjectFileSystem fsWithFilter = new DefaultProjectFileSystem(project, new Languages(Java.INSTANCE), filter);
-    assertThat(fsWithFilter.getSourceFiles()).hasSize(1);
-    assertThat(fsWithFilter.getSourceFiles()).onProperty("name").excludes("Bar.java");
+    assertThat(fsWithFilter.getSourceFiles().size(), is(1));
+    assertThat(fsWithFilter.getSourceFiles(), not(hasItem(named("Bar.java"))));
   }
 
   @Test
   public void testSelectiveFileFilter() {
     DefaultProjectFileSystem.FileSelectionFilter filter = new DefaultProjectFileSystem.FileSelectionFilter(
-        Arrays.asList(new File("foo/Bar.java"), new File("hello/Bar.java"), new File("hello/World.java")));
-    assertThat(filter.accept(new File("foo/Bar.java"))).isTrue();
-    assertThat(filter.accept(new File("hello/Bar.java"))).isTrue();
-    assertThat(filter.accept(new File("hello/World.java"))).isTrue();
-
-    assertThat(filter.accept(new File("foo/Unknown.java"))).isFalse();
-    assertThat(filter.accept(new File("foo/bar/Bar.java"))).isFalse();
-    assertThat(filter.accept(new File("foo/World.java"))).isFalse();
+      Arrays.asList(new File("foo/Bar.java"), new File("hello/Bar.java"), new File("hello/World.java")));
+    assertThat(filter.accept(new File("foo/Bar.java")), Matchers.is(true));
+    assertThat(filter.accept(new File("hello/Bar.java")), Matchers.is(true));
+    assertThat(filter.accept(new File("hello/World.java")), Matchers.is(true));
+
+    assertThat(filter.accept(new File("foo/Unknown.java")), Matchers.is(false));
+    assertThat(filter.accept(new File("foo/bar/Bar.java")), Matchers.is(false));
+    assertThat(filter.accept(new File("foo/World.java")), Matchers.is(false));
   }
 
   /**
@@ -239,8 +236,33 @@ public class DefaultProjectFileSystemTest {
   public void shouldExcludeDirectoriesStartingWithDot() {
     List<File> dirs = Arrays.asList(new File("test-resources/org/sonar/api/resources/DefaultProjectFileSystemTest/shouldExcludeDirectoriesStartingWithDot/src"));
 
-    List<InputFile> files = new DefaultProjectFileSystem(new Project("foo"), null).getFiles(dirs, Collections.<File> emptyList(), new String[0], new String[0], true);
-    assertThat(files).hasSize(1);
-    assertThat(files.get(0).getRelativePath()).isEqualTo("org/sonar/Included.java");
+    List<InputFile> files = new DefaultProjectFileSystem(new Project("foo"), null).getFiles(dirs, Collections.<File>emptyList(), new String[0]);
+    assertThat(files.size(), is(1));
+    assertThat(files.get(0).getRelativePath(), is("org/sonar/Included.java"));
+  }
+
+  private DefaultProjectFileSystem newDefaultProjectFileSystem(Project project) {
+    return (DefaultProjectFileSystem) project.getFileSystem();
+  }
+
+  private static Matcher<java.io.File> named(final String name) {
+    return new TypeSafeMatcher<java.io.File>() {
+      java.io.File fileTested;
+
+      @Override
+      public boolean matchesSafely(java.io.File item) {
+        fileTested = item;
+        return name.equals(item.getName());
+      }
+
+      public void describeTo(Description description) {
+        description.appendText(" that file ");
+        description.appendValue(fileTested);
+        description.appendText(" is named");
+        description.appendText(name);
+        description.appendText(" not ");
+        description.appendValue(fileTested.getName());
+      }
+    };
   }
-}
+}
\ No newline at end of file
diff --git a/sonar-plugin-api/src/test/java/org/sonar/api/resources/ProjectTest.java b/sonar-plugin-api/src/test/java/org/sonar/api/resources/ProjectTest.java
index 2ff1a1a6ec0..81c3f209886 100644
--- a/sonar-plugin-api/src/test/java/org/sonar/api/resources/ProjectTest.java
+++ b/sonar-plugin-api/src/test/java/org/sonar/api/resources/ProjectTest.java
@@ -103,26 +103,4 @@ public class ProjectTest {
 
     assertThat(project.getExclusionPatterns()).containsOnly("**/*Foo.java", "**/*Bar.java");
   }
-
-  @Test
-  public void should_support_inclusion_patterns() {
-    conf.setProperty(CoreProperties.PROJECT_EXCLUSIONS_PROPERTY, "!**/*foo.java, **/*bar.java");
-    conf.setProperty(CoreProperties.GLOBAL_EXCLUSIONS_PROPERTY, "!**/*quix.java");
-
-    Project project = new Project("key").setConfiguration(conf);
-
-    assertThat(project.getExclusionPatterns()).containsOnly("**/*bar.java");
-    assertThat(project.getInclusionPatterns()).containsOnly("**/*foo.java", "**/*quix.java");
-  }
-
-  @Test
-  public void should_support_test_inclusion_patterns() {
-    conf.setProperty(CoreProperties.PROJECT_TEST_EXCLUSIONS_PROPERTY, "!**/*Test.java, **/*FunctionalTest.java");
-    conf.setProperty(CoreProperties.GLOBAL_TEST_EXCLUSIONS_PROPERTY, "!**/*IntegrationTest.java");
-
-    Project project = new Project("key").setConfiguration(conf);
-
-    assertThat(project.getTestExclusionPatterns()).containsOnly("**/*FunctionalTest.java");
-    assertThat(project.getTestInclusionPatterns()).containsOnly("**/*Test.java", "**/*IntegrationTest.java");
-  }
 }