hazendaz / jmockit1 / 85

Committed 26 Apr 2025 06:37PM UTC coverage: 73.285% (-0.02%) from 73.308%

Build # 85

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #327 from hazendaz/paths

Use nio more per modernizer and update more tests to junit 5

Run Details

5625 of 8178 branches covered (68.78%)

Branch coverage included in aggregate %.

5 of 43 new or added lines in 14 files covered. (11.63%)

3 existing lines in 3 files now uncovered.

11885 of 15715 relevant lines covered (75.63%)

0.76 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/main/src/main/java/mockit/coverage/OutputFileGenerator.java

/*
 * Copyright (c) 2006 JMockit developers
 * This file is subject to the terms of the MIT license (see LICENSE.txt).
 */
package mockit.coverage;

import edu.umd.cs.findbugs.annotations.NonNull;
import edu.umd.cs.findbugs.annotations.Nullable;

import java.io.File;
import java.io.IOException;
import java.nio.file.Path;

import mockit.coverage.data.CoverageData;
import mockit.coverage.reporting.CoverageReport;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@SuppressWarnings("DynamicRegexReplaceableByCompiledPattern")
final class OutputFileGenerator {

    /** The logger. */
    private static final Logger logger = LoggerFactory.getLogger(CoverageReport.class);

    private static final String[] ALL_SOURCE_DIRS = {};

    @NonNull
    private final String[] outputFormats;
    @NonNull
    private final String outputDir;
    @Nullable
    private final String[] sourceDirs;

    OutputFileGenerator() {
        outputFormats = getOutputFormat();
        outputDir = Configuration.getProperty("outputDir", "");

        String commaSeparatedDirs = Configuration.getProperty("srcDirs");

        if (commaSeparatedDirs == null) {
            sourceDirs = ALL_SOURCE_DIRS;
        } else if (commaSeparatedDirs.isEmpty()) {
            sourceDirs = null;
        } else {
            sourceDirs = commaSeparatedDirs.split("\\s*,\\s*");
        }
    }

    @NonNull
    private static String[] getOutputFormat() {
        String format = Configuration.getProperty("output", "");
        return format.isEmpty() ? new String[] { "html" } : format.trim().split("\\s*,\\s*|\\s+");
    }

    boolean isOutputToBeGenerated() {
        return isHTMLWithNoCallPoints() || isWithCallPoints() || hasOutputFormat("serial")
                || hasOutputFormat("serial-append") || hasOutputFormat("xml");
    }

    private boolean isHTMLWithNoCallPoints() {
        return hasOutputFormat("html") || hasOutputFormat("html-nocp");
    }

    boolean isWithCallPoints() {
        return hasOutputFormat("html-cp");
    }

    private boolean hasOutputFormat(@NonNull String format) {
        for (String outputFormat : outputFormats) {
            if (format.equals(outputFormat)) {
                return true;
            }
        }

        return false;
    }

    void generate() {
        CoverageData coverageData = CoverageData.instance();

        if (coverageData.isEmpty()) {
            logger.info("JMockit: No classes were instrumented for coverage; please make sure that ");

            String classesRegexp = Configuration.getProperty("classes");

            if (classesRegexp == null) {
                logger.info("classes exercised by tests are in a directory included in the runtime classpath");
            } else {
                logger.info(
                        "classes selected for coverage through the regular expression '{}' are available from the runtime classpath",
                        classesRegexp);
            }

            logger.info(", and that they have been compiled with debug information.");
            return;
        }

        boolean outputDirCreated = createOutputDirIfSpecifiedButNotExists();

        try {
            generateAccretionDataFileIfRequested(coverageData);
            generateXmlDataFileIfRequested(coverageData);
            generateHTMLReportIfRequested(coverageData, outputDirCreated);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    void generateAggregateReportFromInputFiles(@NonNull String[] inputPaths) {
        boolean outputDirCreated = createOutputDirIfSpecifiedButNotExists();

        try {
            CoverageData coverageData = new DataFileMerging(inputPaths).merge();
            generateHTMLReportIfRequested(coverageData, outputDirCreated);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    private boolean createOutputDirIfSpecifiedButNotExists() {
        if (outputDir.isEmpty()) {
            return false;
        }

        File outDir = Path.of(outputDir).toFile();
        return outDir.mkdirs();
    }

    private void generateAccretionDataFileIfRequested(@NonNull CoverageData newData) throws IOException {
        if (hasOutputFormat("serial")) {
            new AccretionFile(outputDir, newData).generate();
        } else if (hasOutputFormat("serial-append")) {
            AccretionFile accretionFile = new AccretionFile(outputDir, newData);
            accretionFile.mergeDataFromExistingFileIfAny();
            accretionFile.generate();
        }
    }

    private void generateXmlDataFileIfRequested(@NonNull CoverageData newData) throws IOException {
        if (hasOutputFormat("xml")) {
            new XmlFile(outputDir, newData).generate();
        }
    }

    private void generateHTMLReportIfRequested(@NonNull CoverageData coverageData, boolean outputDirCreated)
            throws IOException {
        if (isHTMLWithNoCallPoints()) {
            new CoverageReport(outputDir, outputDirCreated, sourceDirs, coverageData, false).generate();
        } else if (isWithCallPoints()) {
            new CoverageReport(outputDir, outputDirCreated, sourceDirs, coverageData, true).generate();
        }
    }
}

1	/*
2	* Copyright (c) 2006 JMockit developers
3	* This file is subject to the terms of the MIT license (see LICENSE.txt).
4	*/
5	package mockit.coverage;
6
7	import edu.umd.cs.findbugs.annotations.NonNull;
8	import edu.umd.cs.findbugs.annotations.Nullable;
9
10	import java.io.File;
11	import java.io.IOException;
12	import java.nio.file.Path;
13
14	import mockit.coverage.data.CoverageData;
15	import mockit.coverage.reporting.CoverageReport;
16
17	import org.slf4j.Logger;
18	import org.slf4j.LoggerFactory;
19
20	@SuppressWarnings("DynamicRegexReplaceableByCompiledPattern")
21	final class OutputFileGenerator {
22
23	/** The logger. */
24	private static final Logger logger = LoggerFactory.getLogger(CoverageReport.class);	×
25
26	private static final String[] ALL_SOURCE_DIRS = {};	×
27
28	@NonNull
29	private final String[] outputFormats;
30	@NonNull
31	private final String outputDir;
32	@Nullable
33	private final String[] sourceDirs;
34
35	OutputFileGenerator() {	×
36	outputFormats = getOutputFormat();	×
37	outputDir = Configuration.getProperty("outputDir", "");	×
38
39	String commaSeparatedDirs = Configuration.getProperty("srcDirs");	×
40
41	if (commaSeparatedDirs == null) {	×
42	sourceDirs = ALL_SOURCE_DIRS;	×
43	} else if (commaSeparatedDirs.isEmpty()) {	×
44	sourceDirs = null;	×
45	} else {
46	sourceDirs = commaSeparatedDirs.split("\\s,\\s");	×
47	}
48	}	×
49
50	@NonNull
51	private static String[] getOutputFormat() {
52	String format = Configuration.getProperty("output", "");	×
53	return format.isEmpty() ? new String[] { "html" } : format.trim().split("\\s,\\s\|\\s+");	×
54	}
55
56	boolean isOutputToBeGenerated() {
57	return isHTMLWithNoCallPoints() \|\| isWithCallPoints() \|\| hasOutputFormat("serial")	×
58	\|\| hasOutputFormat("serial-append") \|\| hasOutputFormat("xml");	×
59	}
60
61	private boolean isHTMLWithNoCallPoints() {
62	return hasOutputFormat("html") \|\| hasOutputFormat("html-nocp");	×
63	}
64
65	boolean isWithCallPoints() {
66	return hasOutputFormat("html-cp");	×
67	}
68
69	private boolean hasOutputFormat(@NonNull String format) {
70	for (String outputFormat : outputFormats) {	×
71	if (format.equals(outputFormat)) {	×
72	return true;	×
73	}
74	}
75
76	return false;	×
77	}
78
79	void generate() {
80	CoverageData coverageData = CoverageData.instance();	×
81
82	if (coverageData.isEmpty()) {	×
83	logger.info("JMockit: No classes were instrumented for coverage; please make sure that ");	×
84
85	String classesRegexp = Configuration.getProperty("classes");	×
86
87	if (classesRegexp == null) {	×
88	logger.info("classes exercised by tests are in a directory included in the runtime classpath");	×
89	} else {
90	logger.info(	×
91	"classes selected for coverage through the regular expression '{}' are available from the runtime classpath",
92	classesRegexp);
93	}
94
95	logger.info(", and that they have been compiled with debug information.");	×
96	return;	×
97	}
98
99	boolean outputDirCreated = createOutputDirIfSpecifiedButNotExists();	×
100
101	try {
102	generateAccretionDataFileIfRequested(coverageData);	×
103	generateXmlDataFileIfRequested(coverageData);	×
104	generateHTMLReportIfRequested(coverageData, outputDirCreated);	×
105	} catch (IOException e) {	×
106	throw new RuntimeException(e);	×
107	}	×
108	}	×
109
110	void generateAggregateReportFromInputFiles(@NonNull String[] inputPaths) {
111	boolean outputDirCreated = createOutputDirIfSpecifiedButNotExists();	×
112
113	try {
114	CoverageData coverageData = new DataFileMerging(inputPaths).merge();	×
115	generateHTMLReportIfRequested(coverageData, outputDirCreated);	×
116	} catch (IOException e) {	×
117	throw new RuntimeException(e);	×
118	}	×
119	}	×
120
121	private boolean createOutputDirIfSpecifiedButNotExists() {
122	if (outputDir.isEmpty()) {	×
123	return false;	×
124	}
125
NEW 126	File outDir = Path.of(outputDir).toFile();	×
127	return outDir.mkdirs();	×
128	}
129
130	private void generateAccretionDataFileIfRequested(@NonNull CoverageData newData) throws IOException {
131	if (hasOutputFormat("serial")) {	×
132	new AccretionFile(outputDir, newData).generate();	×
133	} else if (hasOutputFormat("serial-append")) {	×
134	AccretionFile accretionFile = new AccretionFile(outputDir, newData);	×
135	accretionFile.mergeDataFromExistingFileIfAny();	×
136	accretionFile.generate();	×
137	}
138	}	×
139
140	private void generateXmlDataFileIfRequested(@NonNull CoverageData newData) throws IOException {
141	if (hasOutputFormat("xml")) {	×
142	new XmlFile(outputDir, newData).generate();	×
143	}
144	}	×
145
146	private void generateHTMLReportIfRequested(@NonNull CoverageData coverageData, boolean outputDirCreated)
147	throws IOException {
148	if (isHTMLWithNoCallPoints()) {	×
149	new CoverageReport(outputDir, outputDirCreated, sourceDirs, coverageData, false).generate();	×
150	} else if (isWithCallPoints()) {	×
151	new CoverageReport(outputDir, outputDirCreated, sourceDirs, coverageData, true).generate();	×
152	}
153	}	×
154	}

hazendaz / jmockit1 / 85

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous