Analyzer.java

  1. /*******************************************************************************
  2.  * Copyright (c) 2009, 2025 Mountainminds GmbH & Co. KG and Contributors
  3.  * This program and the accompanying materials are made available under
  4.  * the terms of the Eclipse Public License 2.0 which is available at
  5.  * http://www.eclipse.org/legal/epl-2.0
  6.  *
  7.  * SPDX-License-Identifier: EPL-2.0
  8.  *
  9.  * Contributors:
  10.  *    Marc R. Hoffmann - initial API and implementation
  11.  *
  12.  *******************************************************************************/
  13. package org.jacoco.core.analysis;

  15. import java.io.File;
  16. import java.io.FileInputStream;
  17. import java.io.IOException;
  18. import java.io.InputStream;
  19. import java.util.StringTokenizer;
  20. import java.util.zip.GZIPInputStream;
  21. import java.util.zip.ZipEntry;
  22. import java.util.zip.ZipInputStream;

  24. import org.jacoco.core.JaCoCo;
  25. import org.jacoco.core.data.ExecutionData;
  26. import org.jacoco.core.data.ExecutionDataStore;
  27. import org.jacoco.core.internal.ContentTypeDetector;
  28. import org.jacoco.core.internal.InputStreams;
  29. import org.jacoco.core.internal.Pack200Streams;
  30. import org.jacoco.core.internal.analysis.ClassAnalyzer;
  31. import org.jacoco.core.internal.analysis.ClassCoverageImpl;
  32. import org.jacoco.core.internal.analysis.StringPool;
  33. import org.jacoco.core.internal.data.CRC64;
  34. import org.jacoco.core.internal.flow.ClassProbesAdapter;
  35. import org.jacoco.core.internal.instr.InstrSupport;
  36. import org.objectweb.asm.ClassReader;
  37. import org.objectweb.asm.ClassVisitor;
  38. import org.objectweb.asm.Opcodes;

  40. /**
  41.  * An {@link Analyzer} instance processes a set of Java class files and
  42.  * calculates coverage data for them. For each class file the result is reported
  43.  * to a given {@link ICoverageVisitor} instance. In addition the
  44.  * {@link Analyzer} requires a {@link ExecutionDataStore} instance that holds
  45.  * the execution data for the classes to analyze. The {@link Analyzer} offers
  46.  * several methods to analyze classes from a variety of sources.
  47.  */
  48. public class Analyzer {

  50.     private final ExecutionDataStore executionData;

  52.     private final ICoverageVisitor coverageVisitor;

  54.     private final StringPool stringPool;

  56.     /**
  57.      * Creates a new analyzer reporting to the given output.
  58.      *
  59.      * @param executionData
  60.      *            execution data
  61.      * @param coverageVisitor
  62.      *            the output instance that will coverage data for every analyzed
  63.      *            class
  64.      */
  65.     public Analyzer(final ExecutionDataStore executionData,
  66.             final ICoverageVisitor coverageVisitor) {
  67.         this.executionData = executionData;
  68.         this.coverageVisitor = coverageVisitor;
  69.         this.stringPool = new StringPool();
  70.     }

  72.     /**
  73.      * Creates an ASM class visitor for analysis.
  74.      *
  75.      * @param classid
  76.      *            id of the class calculated with {@link CRC64}
  77.      * @param className
  78.      *            VM name of the class
  79.      * @return ASM visitor to write class definition to
  80.      */
  81.     private ClassVisitor createAnalyzingVisitor(final long classid,
  82.             final String className) {
  83.         final ExecutionData data = executionData.get(classid);
  84.         final boolean[] probes;
  85.         final boolean noMatch;
  86.         if (data == null) {
  87.             probes = null;
  88.             noMatch = executionData.contains(className);
  89.         } else {
  90.             probes = data.getProbes();
  91.             noMatch = false;
  92.         }
  93.         final ClassCoverageImpl coverage = new ClassCoverageImpl(className,
  94.                 classid, noMatch);
  95.         final ClassAnalyzer analyzer = new ClassAnalyzer(coverage, probes,
  96.                 stringPool) {
  97.             @Override
  98.             public void visitEnd() {
  99.                 super.visitEnd();
  100.                 coverageVisitor.visitCoverage(coverage);
  101.             }
  102.         };
  103.         return new ClassProbesAdapter(analyzer, false);
  104.     }

  106.     private void analyzeClass(final byte[] source) {
  107.         final long classId = CRC64.classId(source);
  108.         final ClassReader reader = InstrSupport.classReaderFor(source);
  109.         if ((reader.getAccess() & Opcodes.ACC_MODULE) != 0) {
  110.             return;
  111.         }
  112.         if ((reader.getAccess() & Opcodes.ACC_SYNTHETIC) != 0) {
  113.             return;
  114.         }
  115.         final ClassVisitor visitor = createAnalyzingVisitor(classId,
  116.                 reader.getClassName());
  117.         reader.accept(visitor, 0);
  118.     }

  120.     /**
  121.      * Analyzes the class definition from a given in-memory buffer.
  122.      *
  123.      * @param buffer
  124.      *            class definitions
  125.      * @param location
  126.      *            a location description used for exception messages
  127.      * @throws IOException
  128.      *             if the class can't be analyzed
  129.      */
  130.     public void analyzeClass(final byte[] buffer, final String location)
  131.             throws IOException {
  132.         try {
  133.             analyzeClass(buffer);
  134.         } catch (final RuntimeException cause) {
  135.             throw analyzerError(location, cause);
  136.         }
  137.     }

  139.     /**
  140.      * Analyzes the class definition from a given input stream. The provided
  141.      * {@link InputStream} is not closed by this method.
  142.      *
  143.      * @param input
  144.      *            stream to read class definition from
  145.      * @param location
  146.      *            a location description used for exception messages
  147.      * @throws IOException
  148.      *             if the stream can't be read or the class can't be analyzed
  149.      */
  150.     public void analyzeClass(final InputStream input, final String location)
  151.             throws IOException {
  152.         final byte[] buffer;
  153.         try {
  154.             buffer = InputStreams.readFully(input);
  155.         } catch (final IOException e) {
  156.             throw analyzerError(location, e);
  157.         }
  158.         analyzeClass(buffer, location);
  159.     }

  161.     private IOException analyzerError(final String location,
  162.             final Exception cause) {
  163.         final IOException ex = new IOException(
  164.                 String.format("Error while analyzing %s with JaCoCo %s/%s.",
  165.                         location, JaCoCo.VERSION, JaCoCo.COMMITID_SHORT));
  166.         ex.initCause(cause);
  167.         return ex;
  168.     }

  170.     /**
  171.      * Analyzes all classes found in the given input stream. The input stream
  172.      * may either represent a single class file, a ZIP archive, a Pack200
  173.      * archive or a gzip stream that is searched recursively for class files.
  174.      * All other content types are ignored. The provided {@link InputStream} is
  175.      * not closed by this method.
  176.      *
  177.      * @param input
  178.      *            input data
  179.      * @param location
  180.      *            a location description used for exception messages
  181.      * @return number of class files found
  182.      * @throws IOException
  183.      *             if the stream can't be read or a class can't be analyzed
  184.      */
  185.     public int analyzeAll(final InputStream input, final String location)
  186.             throws IOException {
  187.         final ContentTypeDetector detector;
  188.         try {
  189.             detector = new ContentTypeDetector(input);
  190.         } catch (final IOException e) {
  191.             throw analyzerError(location, e);
  192.         }
  193.         switch (detector.getType()) {
  194.         case ContentTypeDetector.CLASSFILE:
  195.             analyzeClass(detector.getInputStream(), location);
  196.             return 1;
  197.         case ContentTypeDetector.ZIPFILE:
  198.             return analyzeZip(detector.getInputStream(), location);
  199.         case ContentTypeDetector.GZFILE:
  200.             return analyzeGzip(detector.getInputStream(), location);
  201.         case ContentTypeDetector.PACK200FILE:
  202.             return analyzePack200(detector.getInputStream(), location);
  203.         default:
  204.             return 0;
  205.         }
  206.     }

  208.     /**
  209.      * Analyzes all class files contained in the given file or folder. Class
  210.      * files as well as ZIP files are considered. Folders are searched
  211.      * recursively.
  212.      *
  213.      * @param file
  214.      *            file or folder to look for class files
  215.      * @return number of class files found
  216.      * @throws IOException
  217.      *             if the file can't be read or a class can't be analyzed
  218.      */
  219.     public int analyzeAll(final File file) throws IOException {
  220.         int count = 0;
  221.         if (file.isDirectory()) {
  222.             for (final File f : file.listFiles()) {
  223.                 count += analyzeAll(f);
  224.             }
  225.         } else {
  226.             final InputStream in = new FileInputStream(file);
  227.             try {
  228.                 count += analyzeAll(in, file.getPath());
  229.             } finally {
  230.                 in.close();
  231.             }
  232.         }
  233.         return count;
  234.     }

  236.     /**
  237.      * Analyzes all classes from the given class path. Directories containing
  238.      * class files as well as archive files are considered.
  239.      *
  240.      * @param path
  241.      *            path definition
  242.      * @param basedir
  243.      *            optional base directory, if <code>null</code> the current
  244.      *            working directory is used as the base for relative path
  245.      *            entries
  246.      * @return number of class files found
  247.      * @throws IOException
  248.      *             if a file can't be read or a class can't be analyzed
  249.      */
  250.     public int analyzeAll(final String path, final File basedir)
  251.             throws IOException {
  252.         int count = 0;
  253.         final StringTokenizer st = new StringTokenizer(path,
  254.                 File.pathSeparator);
  255.         while (st.hasMoreTokens()) {
  256.             count += analyzeAll(new File(basedir, st.nextToken()));
  257.         }
  258.         return count;
  259.     }

  261.     private int analyzeZip(final InputStream input, final String location)
  262.             throws IOException {
  263.         final ZipInputStream zip = new ZipInputStream(input);
  264.         ZipEntry entry;
  265.         int count = 0;
  266.         while ((entry = nextEntry(zip, location)) != null) {
  267.             count += analyzeAll(zip, location + "@" + entry.getName());
  268.         }
  269.         return count;
  270.     }

  272.     private ZipEntry nextEntry(final ZipInputStream input,
  273.             final String location) throws IOException {
  274.         try {
  275.             return input.getNextEntry();
  276.         } catch (final IOException e) {
  277.             throw analyzerError(location, e);
  278.         } catch (final IllegalArgumentException e) {
  279.             // might be thrown in JDK versions below 23 - see
  280.             // https://bugs.openjdk.org/browse/JDK-8321156
  281.             // https://github.com/openjdk/jdk/commit/20c71ceacdcb791f5b70cda456bdc47bdd9acf6c
  282.             throw analyzerError(location, e);
  283.         }
  284.     }

  286.     private int analyzeGzip(final InputStream input, final String location)
  287.             throws IOException {
  288.         GZIPInputStream gzipInputStream;
  289.         try {
  290.             gzipInputStream = new GZIPInputStream(input);
  291.         } catch (final IOException e) {
  292.             throw analyzerError(location, e);
  293.         }
  294.         return analyzeAll(gzipInputStream, location);
  295.     }

  297.     private int analyzePack200(final InputStream input, final String location)
  298.             throws IOException {
  299.         InputStream unpackedInput;
  300.         try {
  301.             unpackedInput = Pack200Streams.unpack(input);
  302.         } catch (final IOException e) {
  303.             throw analyzerError(location, e);
  304.         }
  305.         return analyzeAll(unpackedInput, location);
  306.     }

  308. }
Created with JaCoCo 0.8.14.202504031211Code Coverage Report for JaCoCo 0.8.14-SNAPSHOT