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

Go to download
/*
 * 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 javax.annotation.*;

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

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

   public IndexPage(
      @Nonnull File outputFile, @Nullable List sourceDirs, @Nullable Collection sourceFilesNotFound,
      @Nonnull Map> packageToFiles, @Nonnull 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(@Nonnull 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("    ");
      }
   }

   @Nonnull
   private static String getCommaSeparatedListOfSourceDirs(@Nonnull 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(@Nonnull Metrics metric)
         {
            writeHeaderCellWithMetricNameAndDescription(metric);
            tableColumn++;
         }

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

      output.println("    ");
   }

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

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

      output.println("    ");
   }

   private void writeLineWithCoverageTotals(@Nonnull 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, @Nonnull final String packageName)
   {
      writeRowStart();
      writeTableCellWithPackageName(packageName);
      writeInternalTableForSourceFiles(packageName);

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

      writeRowClose();
   }

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

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

   private void recordCoverageInformationForPackage(@Nonnull String packageName, @Nonnull 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(@Nonnull String packageName, @Nonnull 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(@Nonnull String packageName, @Nonnull 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(@Nonnull Metrics metric) { recordCoverageInformationForPackage(packageName, metric); }
      });

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

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