import org.sonar.api.component.ResourcePerspectives; //导入依赖的package包/类
public FlowSquidSensor(Settings settings, CheckFactory checkFactory, FileLinesContextFactory fileLinesContextFactory,
                        FileSystem fileSystem, ResourcePerspectives resourcePerspectives, PathResolver pathResolver) {
logger.debug("** FlowSquidSenser constructor");
this.settings = settings;
this.pathResolver = pathResolver;
   this.checks = checkFactory
     .<SquidCheck<Grammar>>create(CheckList.REPOSITORY_KEY)
     .addAnnotatedChecks((Iterable)CheckList.getChecks(settings.getBoolean(FlowPlugin.IGNORE_TOPLEVEL_KEY),false));
   this.nodeChecks = checkFactory
	      .<SquidCheck<Grammar>>create(CheckList.REPOSITORY_KEY)
	      .addAnnotatedChecks((Iterable)CheckList.getChecks(settings.getBoolean(FlowPlugin.IGNORE_TOPLEVEL_KEY), true));
   this.fileLinesContextFactory = fileLinesContextFactory;
   this.fileSystem = fileSystem;
   this.resourcePerspectives = resourcePerspectives;
   this.mainFilePredicates = fileSystem.predicates().and(
     fileSystem.predicates().hasLanguage(FlowLanguage.KEY),
     fileSystem.predicates().hasType(InputFile.Type.MAIN));
 }
 

import org.sonar.api.component.ResourcePerspectives; //导入依赖的package包/类
@Before
  public void createIssueSensorBackedByMocks() {
    ResourcePerspectives resourcePerspectives = mock(ResourcePerspectives.class);
    Checks<Object> checks = mock(Checks.class);
    CheckFactory checkFactory = mock(CheckFactory.class);
    when(checkFactory.create(Mockito.anyString())).thenReturn(checks);
    List<Object> checksList = Arrays.asList(new Object[] {realIfOneStringExistsBothMustExistMultiFileCheck});
    when(checks.all()).thenReturn(checksList);

    when(checks.ruleKey(Mockito.isA(StringDisallowedIfMatchInAnotherFileCheck.class))).thenReturn(RuleKey.of("text", "StringDisallowedIfMatchInAnotherFileCheck"));
    when(checks.ruleKey(Mockito.isA(MultiFileIfOneStringExistsThenBothMustExistCheck.class))).thenReturn(RuleKey.of("text", "MultiFileIfOneStringExistsThenBothMustExistCheck"));
//    realStringDisallowedMultiFileCheck.setRuleKey(RuleKey.parse("text:StringDisallowedIfMatchInAnotherFileCheck")); // Not strictly necessary here. Normally set by the framework to the value in the Check class's annotation

    when(checks.addAnnotatedChecks(Mockito.anyCollection())).thenReturn(checks);
    mockIssuable = mock(Issuable.class);
    when(resourcePerspectives.as(Mockito.eq(Issuable.class), Mockito.isA(InputFile.class))).thenReturn(mockIssuable);
    IssueBuilder mockIssueBuilder = mock(IssueBuilder.class);
    when(mockIssuable.newIssueBuilder()).thenReturn(mockIssueBuilder);
    when(mockIssueBuilder.ruleKey(Mockito.isA(RuleKey.class))).thenReturn(mockIssueBuilder);
    when(mockIssueBuilder.line(Mockito.anyInt())).thenReturn(mockIssueBuilder);
    when(mockIssueBuilder.message(Mockito.anyString())).thenReturn(mockIssueBuilder);
    when(mockIssueBuilder.build()).thenReturn(mock(Issue.class));

    sensor = new TextIssueSensor(fs, resourcePerspectives, checkFactory, project);
  }
 

import org.sonar.api.component.ResourcePerspectives; //导入依赖的package包/类
@Before
  public void createIssueSensorBackedByMocks() {
    ResourcePerspectives resourcePerspectives = mock(ResourcePerspectives.class);
    Checks<Object> checks = mock(Checks.class);
    CheckFactory checkFactory = mock(CheckFactory.class);
    when(checkFactory.create(Mockito.anyString())).thenReturn(checks);
    List<Object> checksList = Arrays.asList(new Object[] {realStringDisallowedMultiFileCheck});
    when(checks.all()).thenReturn(checksList);

    when(checks.ruleKey(Mockito.isA(StringDisallowedIfMatchInAnotherFileCheck.class))).thenReturn(RuleKey.of("text", "StringDisallowedIfMatchInAnotherFileCheck"));
//    realStringDisallowedMultiFileCheck.setRuleKey(RuleKey.parse("text:StringDisallowedIfMatchInAnotherFileCheck")); // Not strictly necessary here. Normally set by the framework to the value in the Check class's annotation

    when(checks.addAnnotatedChecks(Mockito.anyCollection())).thenReturn(checks);
    mockIssuable = mock(Issuable.class);
    when(resourcePerspectives.as(Mockito.eq(Issuable.class), Mockito.isA(InputFile.class))).thenReturn(mockIssuable);
    IssueBuilder mockIssueBuilder = mock(IssueBuilder.class);
    when(mockIssuable.newIssueBuilder()).thenReturn(mockIssueBuilder);
    when(mockIssueBuilder.ruleKey(Mockito.isA(RuleKey.class))).thenReturn(mockIssueBuilder);
    when(mockIssueBuilder.line(Mockito.anyInt())).thenReturn(mockIssueBuilder);
    when(mockIssueBuilder.message(Mockito.anyString())).thenReturn(mockIssueBuilder);
    when(mockIssueBuilder.build()).thenReturn(mock(Issue.class));

    sensor = new TextIssueSensor(fs, resourcePerspectives, checkFactory, project);
  }
 

import org.sonar.api.component.ResourcePerspectives; //导入依赖的package包/类
@Before
public void createIssueSensorBackedByMocks() {
ResourcePerspectives resourcePerspectives = mock(ResourcePerspectives.class);
Checks<Object> checks = mock(Checks.class);
CheckFactory checkFactory = mock(CheckFactory.class);
when(checkFactory.create(Mockito.anyString())).thenReturn(checks);
textCheckMock = mock(AbstractTextCheck.class);
List<Object> checksList = Arrays.asList(new Object[] {textCheckMock});
when(checks.all()).thenReturn(checksList);

when(checks.addAnnotatedChecks(Mockito.anyCollection())).thenReturn(checks);
mockIssuable = mock(Issuable.class);
when(resourcePerspectives.as(Mockito.eq(Issuable.class), Mockito.isA(InputFile.class))).thenReturn(mockIssuable);
IssueBuilder mockIssueBuilder = mock(IssueBuilder.class);
when(mockIssuable.newIssueBuilder()).thenReturn(mockIssueBuilder);
when(mockIssueBuilder.ruleKey(Mockito.isA(RuleKey.class))).thenReturn(mockIssueBuilder);
when(mockIssueBuilder.line(Mockito.anyInt())).thenReturn(mockIssueBuilder);
when(mockIssueBuilder.message(Mockito.anyString())).thenReturn(mockIssueBuilder);
when(mockIssueBuilder.build()).thenReturn(mock(Issue.class));

sensor = new TextIssueSensor(fs, resourcePerspectives, checkFactory, project);
}
 

import org.sonar.api.component.ResourcePerspectives; //导入依赖的package包/类
@Test
public void shouldExecuteOnProject() {
  Settings settings = mock(Settings.class);
  RulesProfile profile = mock(RulesProfile.class);
  DefaultFileSystem fileSystem = new DefaultFileSystem();
  ResourcePerspectives perspectives = mock(ResourcePerspectives.class);

  Project project = mock(Project.class);

  ReSharperSensor sensor = new ReSharperSensor(
    new ReSharperConfiguration("lang", "foo-resharper", "fooReportkey"),
    settings, profile, fileSystem, perspectives);

  assertThat(sensor.shouldExecuteOnProject(project)).isFalse();

  fileSystem.add(new DefaultInputFile("").setAbsolutePath("").setLanguage("foo"));
  when(profile.getActiveRulesByRepository("foo-resharper")).thenReturn(ImmutableList.<ActiveRule>of());
  assertThat(sensor.shouldExecuteOnProject(project)).isFalse();

  fileSystem.add(new DefaultInputFile("").setAbsolutePath("").setLanguage("lang"));
  when(profile.getActiveRulesByRepository("foo-resharper")).thenReturn(ImmutableList.of(mock(ActiveRule.class)));
  assertThat(sensor.shouldExecuteOnProject(project)).isTrue();

  when(profile.getActiveRulesByRepository("foo-resharper")).thenReturn(ImmutableList.<ActiveRule>of());
  assertThat(sensor.shouldExecuteOnProject(project)).isFalse();
}
 

import org.sonar.api.component.ResourcePerspectives; //导入依赖的package包/类
public CoverageSensor(FileSystem fileSystem, ResourcePerspectives perspectives,
    CoverageConfiguration config, ActiveRules activeRules,
    CoverageProjectStore coverageProjectStore, SonarClient sonar) {
  this.fileSystem = fileSystem;
  this.perspectives = perspectives;
  this.config = config;
  this.activeRules = activeRules;
  this.coverageProjectStore = coverageProjectStore;
  this.sonar = sonar;
}
 

import org.sonar.api.component.ResourcePerspectives; //导入依赖的package包/类
/**
 * Default construct to initialize the variables.
 *
 * @param fileSystem source files.
 * @param perspectives perspective from resources.
 * @param checkFactory factory to create a check.
 */
public ApexSquidSensor(FileSystem fileSystem, ResourcePerspectives perspectives, CheckFactory checkFactory) {
    this.checks = checkFactory
            .<SquidAstVisitor<Grammar>>create(CheckList.REPOSITORY_KEY)
            .addAnnotatedChecks(CheckList.getChecks());
    this.fileSystem = fileSystem;
    this.resourcePerspectives = perspectives;

    FilePredicates predicates = fileSystem.predicates();
    filePredicate = predicates.and(
            predicates.hasType(InputFile.Type.MAIN),
            predicates.hasLanguage(Apex.KEY));
}
 

import org.sonar.api.component.ResourcePerspectives; //导入依赖的package包/类
@Before
public void setUp() {
    ActiveRules activeRules = (new ActiveRulesBuilder())
            .create(RuleKey.of(CheckList.REPOSITORY_KEY, "PrintStatementUsage"))
            .setName("Print Statement Usage")
            .activate()
            .build();
    CheckFactory checkFactory = new CheckFactory(activeRules);
    perspectives = mock(ResourcePerspectives.class);
    fileSystem = new DefaultFileSystem(new File("."));
    squidSensor = new ApexSquidSensor(fileSystem, perspectives, checkFactory);
}
 

import org.sonar.api.component.ResourcePerspectives; //导入依赖的package包/类
/**
 * Use of IoC to get FileSystem
 */
public TextIssueSensor(final FileSystem fs, final ResourcePerspectives perspectives, final CheckFactory checkFactory, final Project project) {
  this.checks = checkFactory.create(CheckRepository.REPOSITORY_KEY).addAnnotatedChecks(CheckRepository.getCheckClasses());
  this.fs = fs;
  this.resourcePerspectives = perspectives;
  this.project = project;

  // This data structure is shared across all cross-file checks so they can see each others' data.
  // Each file with any trigger or disallow match gets a listitem indicating the specifics of the Check that matched including line number. This object reference stays with the check and gets referenced later inside the "raiseIssuesAfterScan()" method call.
  this.crossFileChecksRawResults = Maps.newHashMap();
}
 

import org.sonar.api.component.ResourcePerspectives; //导入依赖的package包/类
/**
 * Use of IoC to get FileSystem
 */
public IssueSensor(FileSystem fs, ResourcePerspectives perspectives, ActiveRules activeRules) {
	this.fs = fs;
	this.perspectives = perspectives;
	this.activeRules = activeRules;
	this.activeRules.toString(); // could be used
}
 

import org.sonar.api.component.ResourcePerspectives; //导入依赖的package包/类
public ReSharperSensor(ReSharperConfiguration reSharperConf, Settings settings, RulesProfile profile, FileSystem fileSystem, ResourcePerspectives perspectives) {
  this.reSharperConf = reSharperConf;
  this.settings = settings;
  this.profile = profile;
  this.fileSystem = fileSystem;
  this.perspectives = perspectives;
}
 

import org.sonar.api.component.ResourcePerspectives; //导入依赖的package包/类
@Test
public void testSensorInstantiation() throws Exception {
  CSharpReSharperSensor sensor = new CSharpReSharperSensor(new Settings(), mock(RulesProfile.class), new DefaultFileSystem(), mock(ResourcePerspectives.class));
  ReSharperConfiguration configuration = sensor.getConfiguration();
  assertThat(configuration.languageKey()).isEqualTo("cs");
  assertThat(configuration.repositoryKey()).isEqualTo("resharper-cs");
  assertThat(configuration.reportPathKey()).isEqualTo("sonar.resharper.cs.reportPath");
}
 

import org.sonar.api.component.ResourcePerspectives; //导入依赖的package包/类
@Test
public void testSensorInstantiation() throws Exception {
  VBNetReSharperSensor sensor = new VBNetReSharperSensor(new Settings(), mock(RulesProfile.class), new DefaultFileSystem(), mock(ResourcePerspectives.class));
  ReSharperConfiguration configuration = sensor.getConfiguration();
  assertThat(configuration.languageKey()).isEqualTo("vbnet");
  assertThat(configuration.repositoryKey()).isEqualTo("resharper-vbnet");
  assertThat(configuration.reportPathKey()).isEqualTo("sonar.resharper.vbnet.reportPath");
}
 

import org.sonar.api.component.ResourcePerspectives; //导入依赖的package包/类
public CheckstyleAuditListener(RuleFinder ruleFinder, FileSystem fileSystem,
        ResourcePerspectives perspectives) {
    this.ruleFinder = ruleFinder;
    this.fileSystem = fileSystem;
    this.perspectives = perspectives;
}
 

import org.sonar.api.component.ResourcePerspectives; //导入依赖的package包/类
@Before
public void setup() {
    decorator = new ApexCommonRulesDecorator(mock(FileSystem.class),
            mock(CheckFactory.class),
            mock(ResourcePerspectives.class));
}
 

import org.sonar.api.component.ResourcePerspectives; //导入依赖的package包/类
/**
 * Use of IoC to get ResourcePerspective and FileSystem
 */
public PortabilitySensor(FileSystem fileSystem, ResourcePerspectives perspectives) {
    this.fileSystem = fileSystem;
    this.perspectives = perspectives;
}
 

import org.sonar.api.component.ResourcePerspectives; //导入依赖的package包/类
public CSharpReSharperSensor(Settings settings, RulesProfile profile, FileSystem fileSystem, ResourcePerspectives perspectives) {
  super(RESHARPER_CONF, settings, profile, fileSystem, perspectives);
}
 

import org.sonar.api.component.ResourcePerspectives; //导入依赖的package包/类
public VBNetReSharperSensor(Settings settings, RulesProfile profile, FileSystem fileSystem, ResourcePerspectives perspectives) {
  super(RESHARPER_CONF, settings, profile, fileSystem, perspectives);
}
 

import org.sonar.api.component.ResourcePerspectives; //导入依赖的package包/类
@Test
public void analyze_report_path() throws Exception {
  String languageKey = "foo";
  String reportPathKey = "fooReport";
  Settings settings = new Settings();
  settings.setProperty(ReSharperPlugin.SOLUTION_FILE_PROPERTY_KEY, "CSharpPlayground.sln");
  settings.setProperty(ReSharperPlugin.PROJECT_NAME_PROPERTY_KEY, "MyLibrary");
  settings.setProperty(reportPathKey, "src/test/resources/SensorTest/report.xml");

  RulesProfile profile = mock(RulesProfile.class);
  DefaultFileSystem fileSystem = new DefaultFileSystem();
  ResourcePerspectives perspectives = mock(ResourcePerspectives.class);

  ReSharperSensor sensor = new ReSharperSensor(
    new ReSharperConfiguration(languageKey, "foo-resharper", "fooReport"),
    settings, profile, fileSystem, perspectives);

  List<ActiveRule> activeRules = mockActiveRules("RedundantUsingDirective");
  when(profile.getActiveRulesByRepository("foo-resharper")).thenReturn(activeRules);

  File workingDir = new File("src/test/resources/SensorTest");
  fileSystem.setWorkDir(workingDir);

  DefaultInputFile class1Cs = new DefaultInputFile("MyLibrary/Class1.cs").setAbsolutePath(new File("MyLibrary/Class1.cs").getAbsolutePath()).setLanguage(languageKey);
  fileSystem.add(class1Cs);
  DefaultInputFile assemblyInfoCs = new DefaultInputFile("MyLibrary/Properties/AssemblyInfo.cs").setAbsolutePath(new File("MyLibrary/Properties/AssemblyInfo.cs").getAbsolutePath()).setLanguage(languageKey);
  fileSystem.add(assemblyInfoCs);

  Issue issue1 = mock(Issue.class);
  IssueBuilder issueBuilder1 = mockIssueBuilder();
  when(issueBuilder1.build()).thenReturn(issue1);

  Issuable issuable1 = mock(Issuable.class);
  when(perspectives.as(Issuable.class, class1Cs)).thenReturn(issuable1);
  when(issuable1.newIssueBuilder()).thenReturn(issueBuilder1);

  Issue issue2 = mock(Issue.class);
  IssueBuilder issueBuilder2 = mockIssueBuilder();
  when(issueBuilder2.build()).thenReturn(issue2);

  Issuable issuable2 = mock(Issuable.class);
  when(perspectives.as(Issuable.class, assemblyInfoCs)).thenReturn(issuable2);
  when(issuable2.newIssueBuilder()).thenReturn(issueBuilder2);

  sensor.analyse(mock(Project.class), mock(SensorContext.class));

  verify(issuable1).addIssue(issue1);
  verify(issuable2).addIssue(issue2);

  verify(issueBuilder1).line(1);
  verify(issueBuilder1).message("Using directive is not required by the code and can be safely removed");

  verify(issueBuilder2).line(2);
  verify(issueBuilder2).message("Using directive is not required by the code and can be safely removed");
}
 

import org.sonar.api.component.ResourcePerspectives; //导入依赖的package包/类
private static ReSharperSensor createReSharperSensor(Settings settings) {
  ReSharperConfiguration reSharperConf = new ReSharperConfiguration("", "", ReSharperPlugin.CS_REPORT_PATH_KEY);
  return new ReSharperSensor(reSharperConf, settings, mock(RulesProfile.class), mock(FileSystem.class), mock(ResourcePerspectives.class));
}