mockit.coverage.reporting.packages.IndexPage Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jmockit-coverage Show documentation
JMockit Coverage is a code coverage tool with several metrics (line, path, data) capable of generating HTML reports. It is designed with ease of use in mind, avoiding the need for complex configuration. Instead, smart (but overridable) defaults are employed, such as the selection of which classes to consider for coverage, and where to find sources files for report generation.
There is a newer version: 1.23
Show newest version
/*
 * Copyright (c) 2006-2015 Rogério Liesenfeld
 * This file is subject to the terms of the MIT license (see LICENSE.txt).
 */
package mockit.coverage.reporting.packages;

import java.io.*;
import java.lang.reflect.*;
import java.util.*;

import mockit.coverage.*;
import mockit.coverage.data.*;
import mockit.coverage.reporting.*;
import mockit.coverage.testRedundancy.*;

import org.jetbrains.annotations.*;

public final class IndexPage extends ListWithFilesAndPercentages
{
   @Nullable private final List sourceDirs;
   @NotNull private final Map> packageToFiles;
   @NotNull private final Map packageToPackagePercentages;
   @NotNull private final PackageCoverageReport packageReport;
   private final int totalFileCount;

   public IndexPage(
      @NotNull File outputFile, @Nullable List sourceDirs, @Nullable Collection sourceFilesNotFound,
      @NotNull Map> packageToFiles, @NotNull Map fileToFileData)
      throws IOException
   {
      super(new OutputFile(outputFile), "    ");
      this.sourceDirs = sourceDirs;
      this.packageToFiles = packageToFiles;
      packageToPackagePercentages = new HashMap();
      packageReport = new PackageCoverageReport(output, sourceFilesNotFound, fileToFileData, packageToFiles.values());
      totalFileCount = totalNumberOfSourceFilesWithCoverageData(fileToFileData.values());
   }

   private static int totalNumberOfSourceFilesWithCoverageData(@NotNull Collection fileData)
   {
      return fileData.size() - Collections.frequency(fileData, null);
   }

   public void generate()
   {
      try {
         writeHeader();

         List packages = new ArrayList(packageToFiles.keySet());
         writeMetricsForEachFile(null, packages);
         writeLineWithCoverageTotals();
         output.println("  ");

         writeListOfRedundantTestsIfAny();
         writeFooter();
      }
      finally {
         output.close();
      }
   }

   private void writeHeader()
   {
      ((OutputFile) output).writeCommonHeader("Code Coverage Report");

      output.println("  ");

      writeTableCaption();
      writeTableFirstRowWithColumnTitles();
   }

   private void writeTableCaption()
   {
      if (sourceDirs == null) {
         output.println("    ");
      }
      else {
         output.write("    ");
      }
   }

   @NotNull
   private static String getCommaSeparatedListOfSourceDirs(@NotNull String concatenatedSourceDirs)
   {
      String prefixToRemove = ".." + File.separatorChar;
      String commaSepDirs = concatenatedSourceDirs.replace(prefixToRemove, "");
      return commaSepDirs.substring(1, commaSepDirs.length() - 1);
   }

   private void writeTableFirstRowWithColumnTitles()
   {
      output.println("    ");
      output.write("      ");
      output.write(
         "      ");

      Metrics.performAction(new Metrics.Action() {
         int tableColumn = 1;

         @Override
         public void perform(@NotNull Metrics metric)
         {
            writeHeaderCellWithMetricNameAndDescription(metric);
            tableColumn++;
         }

         private void writeHeaderCellWithMetricNameAndDescription(@NotNull Metrics metric)
         {
            output.write("      ");
         }
      });

      output.println("    ");
   }

   private void writeLineWithCoverageTotals()
   {
      output.println("    ");
      output.println("      ");

      Metrics.performAction(new Metrics.Action() {
         @Override
         public void perform(@NotNull Metrics metric) { writeLineWithCoverageTotals(metric); }
      });

      output.println("    ");
   }

   private void writeLineWithCoverageTotals(@NotNull Metrics metric)
   {
      int covered = coveredItems[metric.ordinal()];
      int total = totalItems[metric.ordinal()];
      int percentage = CoveragePercentage.calculate(covered, total);

      printCoveragePercentage(metric, covered, total, percentage);
   }

   @Override @SuppressWarnings("ParameterNameDiffersFromOverriddenParameter")
   protected void writeMetricsForFile(String unused, @NotNull final String packageName)
   {
      writeRowStart();
      writeTableCellWithPackageName(packageName);
      writeInternalTableForSourceFiles(packageName);

      Metrics.performAction(new Metrics.Action() {
         @Override
         public void perform(@NotNull Metrics metric) { writeCoveragePercentageForPackage(packageName, metric); }
      });

      writeRowClose();
   }

   private void writeTableCellWithPackageName(@NotNull String packageName)
   {
      printIndent();
      output.write("  ");
   }

   private void writeInternalTableForSourceFiles(@NotNull final String packageName)
   {
      printIndent();
      output.println("  ");
   }

   private void recordCoverageInformationForPackage(@NotNull String packageName, @NotNull Metrics metric)
   {
      int coveredInPackage = packageReport.coveredItems[metric.ordinal()];
      int totalInPackage = packageReport.totalItems[metric.ordinal()];
      int packagePercentage = CoveragePercentage.calculate(coveredInPackage, totalInPackage);

      setPackageCoveragePercentage(packageName, metric, packagePercentage);

      totalItems[metric.ordinal()] += totalInPackage;
      coveredItems[metric.ordinal()] += coveredInPackage;
   }

   private void setPackageCoveragePercentage(@NotNull String packageName, @NotNull Metrics metric, int percentage)
   {
      int[] percentages = packageToPackagePercentages.get(packageName);

      if (percentages == null) {
         percentages = new int[Metrics.values().length];
         packageToPackagePercentages.put(packageName, percentages);
      }

      percentages[metric.ordinal()] = percentage;
   }

   private void writeInitiallyHiddenSourceFileCount(int fileCount)
   {
      output.write("    (");
      output.print(fileCount);
      output.println(" source files)");
   }

   private void writeCoveragePercentageForPackage(@NotNull String packageName, @NotNull Metrics metric)
   {
      int coveredInPackage = packageReport.coveredItems[metric.ordinal()];
      int totalInPackage = packageReport.totalItems[metric.ordinal()];
      int filePercentage = packageToPackagePercentages.get(packageName)[metric.ordinal()];

      printCoveragePercentage(metric, coveredInPackage, totalInPackage, filePercentage);
   }

   @Override
   protected void writeClassAttributeForCoveragePercentageCell()
   {
      output.write("class='pt' ");
   }

   private void writeListOfRedundantTestsIfAny()
   {
      List redundantTests = TestCoverage.INSTANCE.getRedundantTests();

      if (!redundantTests.isEmpty()) {
         output.println("  
Redundant tests:");
         output.println(
            "  ");

         for (Method testMethod : redundantTests) {
            String testDescription = testMethod.getDeclaringClass().getSimpleName() + '.' + testMethod.getName();

            output.append("");
            output.write("    ");
            output.write(testDescription);
            output.println("");
         }

         output.println("  ");
      }
   }

   private void writeFooter()
   {
      output.println("  ");
      output.println("    ");
      output.write("    Generated on ");
      output.println(new Date());
      output.println("  ");
      ((OutputFile) output).writeCommonFooter();
   }
}
    

    







    © 2015 - 2025 Weber Informatics LLC | Privacy Policy










All Packages and FilesAll Packages and Files");
         output.write(getCommaSeparatedListOfSourceDirs(sourceDirs.toString()));
         output.println("Packages: ");
      output.print(packageToFiles.keySet().size());
      output.println(" Files: ");
      output.print(totalFileCount);
      output.println(" ");
            output.write(metric.toString());
            output.println("
Total  
");
      output.write(packageName.replace('/', '.'));
      output.println(" ");

      printIndent();
      output.println("    ");

      List fileNames = packageToFiles.get(packageName);
      packageReport.writeMetricsForEachFile(packageName, fileNames);

      Metrics.performAction(new Metrics.Action() {
         @Override
         public void perform(@NotNull Metrics metric) { recordCoverageInformationForPackage(packageName, metric); }
      });

      printIndent();
      output.println("    ");
      printIndent();

      writeInitiallyHiddenSourceFileCount(fileNames.size());
      output.println("