@Test
  public void supportJavaSuppressWarning() throws Exception {
    ClientInputFile inputFile =
        prepareInputFile(
            "Foo.java",
            "public class Foo {\n"
                + "  @SuppressWarnings(\"squid:S106\")\n"
                + "  public void foo() {\n"
                + "    int x;\n"
                + "    System.out.println(\"Foo\");\n"
                + "    System.out.println(\"Foo\"); //NOSONAR\n"
                + "  }\n"
                + "}",
            false);

    final List<Issue> issues = new ArrayList<>();
    sonarlint.analyze(
        new StandaloneAnalysisConfiguration(
            baseDir.toPath(),
            temp.newFolder().toPath(),
            Arrays.asList(inputFile),
            ImmutableMap.of()),
        issue -> issues.add(issue));

    assertThat(issues)
        .extracting("ruleKey", "startLine", "inputFile.path", "severity")
        .containsOnly(
            tuple("squid:UndocumentedApi", 1, inputFile.getPath(), "MINOR"),
            tuple("squid:UndocumentedApi", 3, inputFile.getPath(), "MINOR"),
            tuple("squid:S1220", null, inputFile.getPath(), "MINOR"),
            tuple("squid:S1481", 4, inputFile.getPath(), "MAJOR"));
  }
  @Test
  public void simpleJavaScript() throws Exception {

    RuleDetails ruleDetails = sonarlint.getRuleDetails("javascript:UnusedVariable");
    assertThat(ruleDetails.getName()).isEqualTo("Unused local variables should be removed");
    assertThat(ruleDetails.getLanguage()).isEqualTo("js");
    assertThat(ruleDetails.getSeverity()).isEqualTo("MAJOR");
    assertThat(ruleDetails.getTags()).containsOnly("unused");
    assertThat(ruleDetails.getHtmlDescription())
        .contains("<p>", "If a local variable is declared but not used");

    ClientInputFile inputFile =
        prepareInputFile(
            "foo.js", "function foo() {\n" + "  var x;\n" + "  var y; //NOSONAR\n" + "}", false);

    final List<Issue> issues = new ArrayList<>();
    sonarlint.analyze(
        new StandaloneAnalysisConfiguration(
            baseDir.toPath(),
            temp.newFolder().toPath(),
            Arrays.asList(inputFile),
            ImmutableMap.of()),
        i -> issues.add(i));
    assertThat(issues)
        .extracting("ruleKey", "startLine", "inputFile.path")
        .containsOnly(tuple("javascript:UnusedVariable", 2, inputFile.getPath()));
  }
  @Test
  public void simpleJavaPomXml() throws Exception {
    ClientInputFile inputFile =
        prepareInputFile(
            "pom.xml",
            "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
                + "<project>\n"
                + "  <modelVersion>4.0.0</modelVersion>\n"
                + "  <groupId>com.foo</groupId>\n"
                + "  <artifactId>bar</artifactId>\n"
                + "  <version>${pom.version}</version>\n"
                + "</project>",
            false);

    final List<Issue> issues = new ArrayList<>();
    sonarlint.analyze(
        new StandaloneAnalysisConfiguration(
            baseDir.toPath(),
            temp.newFolder().toPath(),
            Arrays.asList(inputFile),
            ImmutableMap.of()),
        issue -> issues.add(issue));

    assertThat(issues)
        .extracting("ruleKey", "startLine", "inputFile.path", "severity")
        .containsOnly(tuple("squid:S3421", 6, inputFile.getPath(), "MAJOR"));
  }
  @Test
  public void simplePhp() throws Exception {

    ClientInputFile inputFile =
        prepareInputFile(
            "foo.php",
            "<?php\n"
                + "function writeMsg($fname) {\n"
                + "    $i = 0; // NOSONAR\n"
                + "    echo \"Hello world!\";\n"
                + "}\n"
                + "?>",
            false);

    final List<Issue> issues = new ArrayList<>();
    sonarlint.analyze(
        new StandaloneAnalysisConfiguration(
            baseDir.toPath(),
            temp.newFolder().toPath(),
            Arrays.asList(inputFile),
            ImmutableMap.of()),
        issue -> issues.add(issue));
    assertThat(issues)
        .extracting("ruleKey", "startLine", "inputFile.path")
        .containsOnly(tuple("php:S1172", 2, inputFile.getPath()));
  }
  @Test
  public void analysisErrors() throws Exception {
    ClientInputFile inputFile =
        prepareInputFile(
            "foo.xoo", "function foo() {\n" + "  var xoo;\n" + "  var y; //NOSONAR\n" + "}", false);
    prepareInputFile("foo.xoo.error", "1,2,error analysing\n2,3,error analysing", false);

    final List<Issue> issues = new ArrayList<>();
    AnalysisResults results =
        sonarlint.analyze(
            new StandaloneAnalysisConfiguration(
                baseDir.toPath(),
                temp.newFolder().toPath(),
                Arrays.asList(inputFile),
                ImmutableMap.of()),
            issue -> issues.add(issue));
    assertThat(results.failedAnalysisFiles()).containsExactly(inputFile);
    assertThat(issues)
        .extracting("ruleKey", "startLine", "startLineOffset", "inputFile.path")
        .containsOnly(tuple("xoo:HasTag", 2, 6, inputFile.getPath()));
  }
  @Test
  public void simpleJavaWithBytecode() throws Exception {
    ClientInputFile inputFile =
        TestUtils.createInputFile(
            new File("src/test/projects/java-with-bytecode/src/Foo.java")
                .getAbsoluteFile()
                .toPath(),
            false);

    final List<Issue> issues = new ArrayList<>();
    sonarlint.analyze(
        new StandaloneAnalysisConfiguration(
            baseDir.toPath(),
            temp.newFolder().toPath(),
            Arrays.asList(inputFile),
            ImmutableMap.of(
                "sonar.java.binaries",
                new File("src/test/projects/java-with-bytecode/bin").getAbsolutePath())),
        issue -> issues.add(issue));

    assertThat(issues)
        .extracting("ruleKey", "startLine", "inputFile.path")
        .containsOnly(
            tuple("squid:S106", 5, inputFile.getPath()),
            tuple("squid:S1220", null, inputFile.getPath()),
            tuple("squid:UndocumentedApi", 1, inputFile.getPath()),
            tuple("squid:UndocumentedApi", 3, inputFile.getPath()),
            tuple("squid:UnusedPrivateMethod", 8, inputFile.getPath()),
            tuple("squid:S1186", 8, inputFile.getPath()));
  }
  @Test
  public void simpleXoo() throws Exception {
    ClientInputFile inputFile =
        prepareInputFile(
            "foo.xoo",
            "function xoo() {\n" + "  var xoo1, xoo2;\n" + "  var xoo; //NOSONAR\n" + "}",
            false);

    final List<Issue> issues = new ArrayList<>();
    sonarlint.analyze(
        new StandaloneAnalysisConfiguration(
            baseDir.toPath(),
            temp.newFolder().toPath(),
            Arrays.asList(inputFile),
            ImmutableMap.of()),
        issue -> issues.add(issue));
    assertThat(issues)
        .extracting("ruleKey", "startLine", "startLineOffset", "inputFile.path")
        .containsOnly(
            tuple("xoo:HasTag", 1, 9, inputFile.getPath()),
            tuple("xoo:HasTag", 2, 6, inputFile.getPath()),
            tuple("xoo:HasTag", 2, 12, inputFile.getPath()));
  }
  @Test
  public void testJavaSurefireDontCrashAnalysis() throws Exception {

    File surefireReport = new File(baseDir, "reports/TEST-FooTest.xml");
    FileUtils.write(
        surefireReport,
        "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
            + "<testsuite name=\"FooTest\" time=\"0.121\" tests=\"1\" errors=\"0\" skipped=\"0\" failures=\"0\">\n"
            + "<testcase name=\"errorAnalysis\" classname=\"FooTest\" time=\"0.031\"/>\n"
            + "</testsuite>");

    ClientInputFile inputFile =
        prepareInputFile(
            "Foo.java",
            "public class Foo {\n"
                + "  public void foo() {\n"
                + "    int x;\n"
                + "    System.out.println(\"Foo\");\n"
                + "    System.out.println(\"Foo\"); //NOSONAR\n"
                + "  }\n"
                + "}",
            false);

    ClientInputFile inputFileTest =
        prepareInputFile(
            "FooTest.java",
            "public class FooTest {\n" + "  public void testFoo() {\n" + "  }\n" + "}",
            true);

    final List<Issue> issues = new ArrayList<>();
    AnalysisResults results =
        sonarlint.analyze(
            new StandaloneAnalysisConfiguration(
                baseDir.toPath(),
                temp.newFolder().toPath(),
                Arrays.asList(inputFile, inputFileTest),
                ImmutableMap.of("sonar.junit.reportsPath", "reports/")),
            issue -> issues.add(issue));

    assertThat(results.fileCount()).isEqualTo(2);

    assertThat(issues)
        .extracting("ruleKey", "startLine", "inputFile.path")
        .containsOnly(
            tuple("squid:S106", 4, inputFile.getPath()),
            tuple("squid:S1220", null, inputFile.getPath()),
            tuple("squid:UndocumentedApi", 1, inputFile.getPath()),
            tuple("squid:UndocumentedApi", 2, inputFile.getPath()),
            tuple("squid:S1481", 3, inputFile.getPath()),
            tuple("squid:S2187", 1, inputFileTest.getPath()));
  }
  @Test
  public void simplePython() throws Exception {

    ClientInputFile inputFile =
        prepareInputFile(
            "foo.py",
            "def my_function(name):\n"
                + "    print \"Hello\"\n"
                + "    print \"world!\" # NOSONAR\n"
                + "\n",
            false);

    final List<Issue> issues = new ArrayList<>();
    sonarlint.analyze(
        new StandaloneAnalysisConfiguration(
            baseDir.toPath(),
            temp.newFolder().toPath(),
            Arrays.asList(inputFile),
            ImmutableMap.of()),
        issue -> issues.add(issue));
    assertThat(issues)
        .extracting("ruleKey", "startLine", "inputFile.path")
        .containsOnly(tuple("python:PrintStatementUsage", 2, inputFile.getPath()));
  }