pmd / pmd / 830

Committed 25 Sep 2026 03:07PM UTC coverage: 79.731%. Remained the same

Build # 830

Build Type

push

github

Committed by

web-flow

Commit Message

chore: Replace system-lambda with system-stubs (#7114)

* chore: Replace system-lambda with system-stubs

* Update comment

---------

Co-authored-by: Sören Glimm <git@uncleowen.de>

Coverage Stats

20252 of 26446 branches covered (76.58%)

Branch coverage included in aggregate %.

0 of 3 new or added lines in 1 file covered. (0.0%)

43589 of 53624 relevant lines covered (81.29%)

0.82 hits per line

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

0.0

/pmd-test/src/main/java/net/sourceforge/pmd/test/AbstractAntTestHelper.java

/*
 * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
 */

package net.sourceforge.pmd.test;

import static java.io.File.separator;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.not;
import static uk.org.webcompere.systemstubs.SystemStubs.restoreSystemProperties;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.PrintStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Locale;

import org.apache.tools.ant.BuildEvent;
import org.apache.tools.ant.DefaultLogger;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.ProjectHelper;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.io.TempDir;

import net.sourceforge.pmd.internal.Slf4jSimpleConfiguration;

import uk.org.webcompere.systemstubs.SystemStubs;
import uk.org.webcompere.systemstubs.ThrowingRunnable;

/**
 * Base test class for ant tests.
 *
 * <p>Usage template:
 *
 * <pre>
 * class MyPMDTaskTest extends AbstractAntTestHelper {
 *     MyPMDTaskTest() {
 *          antTestScriptFilename = "mypmdtasktest.xml";
 *     }
 *
 *     &#64;Test
 *     void myTest() {
 *         executeTarget("testMyTarget");
 *         assertOutputContaining("Expected Violation Message");
 *     }
 * }
 * </pre>
 *
 * @author Romain Pelisse &lt;belaran@gmail.com&gt;
 *
 */
public abstract class AbstractAntTestHelper {

    @TempDir
    private Path tempFolder;

    protected String pathToTestScript;
    protected String antTestScriptFilename;

    private Project antProject;
    private StringBuilder log = new StringBuilder();
    private String output;

    public AbstractAntTestHelper() {
        pathToTestScript = "target/test-classes/net/sourceforge/pmd/ant/xml";
    }

    @BeforeEach
    public void setUp() throws IOException {
        validatePostConstruct();
        // initialize Ant
        antProject = new Project();
        antProject.init();
        antProject.addBuildListener(new AntBuildListener());
        ProjectHelper.configureProject(antProject, new File(pathToTestScript + separator + antTestScriptFilename));

        // Each test case gets one temp file name, accessible with property ${tmpfile}
        Path tmpFile = Files.createTempFile(tempFolder, "pmd-ant-tests", null);
        // we delete the tmpfile again, since we only wanted to have a unique temp filename
        // the tmpfile is used for creating reports.
        Files.deleteIfExists(tmpFile);
        antProject.setProperty("tmpfile", tmpFile.toAbsolutePath().toString());
    }

    @AfterAll
    static void resetLogging() {
        Slf4jSimpleConfiguration.reconfigureDefaultLogLevel(null);
    }

    /**
     * Returns the current temporary file. Replaced by a fresh (inexistent)
     * file before each test.
     */
    public File currentTempFile() {
        String tmpname = antProject.getProperty("tmpfile");
        return tmpname == null ? null : new File(tmpname);
    }


    private void validatePostConstruct() {
        if (pathToTestScript == null || "".equals(pathToTestScript) || antTestScriptFilename == null
                || "".equals(antTestScriptFilename)) {
            throw new IllegalStateException("Unit tests for Ant script badly initialized");
        }
    }

    public String executeTarget(String target) {
        try {
            restoreLocale(() -> {
                // restoring system properties: Test might change file.encoding or might change logging properties
                // See Slf4jSimpleConfigurationForAnt and resetLogging
                restoreSystemProperties(() -> {
                    output = tapSystemOut(() -> {
                        antProject.executeTarget(target);
                    });
                });
            });
            return output;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    protected String getLog() {
        return log.toString();
    }

    public void assertOutputContaining(String text) {
        assertThat(output, containsString(text));
    }


    public void assertContains(String text, String toFind) {
        assertThat(text, containsString(toFind));
    }


    public void assertDoesntContain(String text, String toFind) {
        assertThat(text, not(containsString(toFind)));
    }

    private static void restoreLocale(ThrowingRunnable statement) throws Exception {
        Locale originalLocale = Locale.getDefault();
        try {
            statement.asCallable().call();
        } finally {
            Locale.setDefault(originalLocale);
        }
    }

    /**
     * This is similar to {@link SystemStubs#tapSystemOut(ThrowingRunnable)}. But this
     * method doesn't use the platform default charset as it was when the JVM started.
     * Instead, it uses the current system property {@code file.encoding}. This allows
     * tests to change the encoding.
     *
     * @param statement an arbitrary piece of code.
     * @return text that is written to stdout. Lineendings are normalized to {@code \n}.
     * @throws Exception any exception thrown by the statement
     */
    private static String tapSystemOut(ThrowingRunnable statement) throws Exception {
        @SuppressWarnings("PMD.CloseResource") // we don't want to close System.out
        PrintStream originalOut = System.out;
        ByteArrayOutputStream text = new ByteArrayOutputStream();
        String currentDefaultCharset = System.getProperty("file.encoding");
        try {
            PrintStream replacement = new PrintStream(text, true, currentDefaultCharset);
            System.setOut(replacement);
            statement.asCallable().call();
        } finally {
            System.setOut(originalOut);
        }
        String result = text.toString(currentDefaultCharset);
        return result.replace(System.lineSeparator(), "\n");
    }

    private final class AntBuildListener extends DefaultLogger {
        private AntBuildListener() {
            msgOutputLevel = Project.MSG_INFO;
        }

        @Override
        protected void printMessage(String message, PrintStream stream, int priority) {
            log.append(message);
        }

        @Override
        public void messageLogged(BuildEvent buildEvent) {
            if (buildEvent.getPriority() <= Project.MSG_INFO) {
                log.append(buildEvent.getMessage());
            }
        }
    }
}

1	/*
2	* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
3	*/
4
5	package net.sourceforge.pmd.test;
6
7	import static java.io.File.separator;
8	import static org.hamcrest.MatcherAssert.assertThat;
9	import static org.hamcrest.Matchers.containsString;
10	import static org.hamcrest.Matchers.not;
11	import static uk.org.webcompere.systemstubs.SystemStubs.restoreSystemProperties;
12
13	import java.io.ByteArrayOutputStream;
14	import java.io.File;
15	import java.io.IOException;
16	import java.io.PrintStream;
17	import java.nio.file.Files;
18	import java.nio.file.Path;
19	import java.util.Locale;
20
21	import org.apache.tools.ant.BuildEvent;
22	import org.apache.tools.ant.DefaultLogger;
23	import org.apache.tools.ant.Project;
24	import org.apache.tools.ant.ProjectHelper;
25	import org.junit.jupiter.api.AfterAll;
26	import org.junit.jupiter.api.BeforeEach;
27	import org.junit.jupiter.api.io.TempDir;
28
29	import net.sourceforge.pmd.internal.Slf4jSimpleConfiguration;
30
31	import uk.org.webcompere.systemstubs.SystemStubs;
32	import uk.org.webcompere.systemstubs.ThrowingRunnable;
33
34	/**
35	* Base test class for ant tests.
36	*
37	* <p>Usage template:
38	*
39	* <pre>
40	* class MyPMDTaskTest extends AbstractAntTestHelper {
41	* MyPMDTaskTest() {
42	* antTestScriptFilename = "mypmdtasktest.xml";
43	* }
44	*
45	* @Test
46	* void myTest() {
47	* executeTarget("testMyTarget");
48	* assertOutputContaining("Expected Violation Message");
49	* }
50	* }
51	* </pre>
52	*
53	* @author Romain Pelisse <belaran@gmail.com>
54	*
55	*/
56	public abstract class AbstractAntTestHelper {
57
58	@TempDir
59	private Path tempFolder;
60
61	protected String pathToTestScript;
62	protected String antTestScriptFilename;
63
64	private Project antProject;
65	private StringBuilder log = new StringBuilder();	×
66	private String output;
67
68	public AbstractAntTestHelper() {	×
69	pathToTestScript = "target/test-classes/net/sourceforge/pmd/ant/xml";	×
70	}	×
71
72	@BeforeEach
73	public void setUp() throws IOException {
74	validatePostConstruct();	×
75	// initialize Ant
76	antProject = new Project();	×
77	antProject.init();	×
78	antProject.addBuildListener(new AntBuildListener());	×
79	ProjectHelper.configureProject(antProject, new File(pathToTestScript + separator + antTestScriptFilename));	×
80
81	// Each test case gets one temp file name, accessible with property ${tmpfile}
82	Path tmpFile = Files.createTempFile(tempFolder, "pmd-ant-tests", null);	×
83	// we delete the tmpfile again, since we only wanted to have a unique temp filename
84	// the tmpfile is used for creating reports.
85	Files.deleteIfExists(tmpFile);	×
86	antProject.setProperty("tmpfile", tmpFile.toAbsolutePath().toString());	×
87	}	×
88
89	@AfterAll
90	static void resetLogging() {
91	Slf4jSimpleConfiguration.reconfigureDefaultLogLevel(null);	×
92	}	×
93
94	/**
95	* Returns the current temporary file. Replaced by a fresh (inexistent)
96	* file before each test.
97	*/
98	public File currentTempFile() {
99	String tmpname = antProject.getProperty("tmpfile");	×
100	return tmpname == null ? null : new File(tmpname);	×
101	}
102
103
104	private void validatePostConstruct() {
105	if (pathToTestScript == null \|\| "".equals(pathToTestScript) \|\| antTestScriptFilename == null	×
106	\|\| "".equals(antTestScriptFilename)) {	×
107	throw new IllegalStateException("Unit tests for Ant script badly initialized");	×
108	}
109	}	×
110
111	public String executeTarget(String target) {
112	try {
113	restoreLocale(() -> {	×
114	// restoring system properties: Test might change file.encoding or might change logging properties
115	// See Slf4jSimpleConfigurationForAnt and resetLogging
NEW 116	restoreSystemProperties(() -> {	×
117	output = tapSystemOut(() -> {	×
118	antProject.executeTarget(target);	×
119	});	×
120	});	×
121	});	×
122	return output;	×
123	} catch (Exception e) {	×
124	throw new RuntimeException(e);	×
125	}
126	}
127
128	protected String getLog() {
129	return log.toString();	×
130	}
131
132	public void assertOutputContaining(String text) {
133	assertThat(output, containsString(text));	×
134	}	×
135
136
137	public void assertContains(String text, String toFind) {
138	assertThat(text, containsString(toFind));	×
139	}	×
140
141
142	public void assertDoesntContain(String text, String toFind) {
143	assertThat(text, not(containsString(toFind)));	×
144	}	×
145
146	private static void restoreLocale(ThrowingRunnable statement) throws Exception {
147	Locale originalLocale = Locale.getDefault();	×
148	try {
NEW 149	statement.asCallable().call();	×
150	} finally {
151	Locale.setDefault(originalLocale);	×
152	}
153	}	×
154
155	/**
156	* This is similar to {@link SystemStubs#tapSystemOut(ThrowingRunnable)}. But this
157	* method doesn't use the platform default charset as it was when the JVM started.
158	* Instead, it uses the current system property {@code file.encoding}. This allows
159	* tests to change the encoding.
160	*
161	* @param statement an arbitrary piece of code.
162	* @return text that is written to stdout. Lineendings are normalized to {@code \n}.
163	* @throws Exception any exception thrown by the statement
164	*/
165	private static String tapSystemOut(ThrowingRunnable statement) throws Exception {
166	@SuppressWarnings("PMD.CloseResource") // we don't want to close System.out
167	PrintStream originalOut = System.out;	×
168	ByteArrayOutputStream text = new ByteArrayOutputStream();	×
169	String currentDefaultCharset = System.getProperty("file.encoding");	×
170	try {
171	PrintStream replacement = new PrintStream(text, true, currentDefaultCharset);	×
172	System.setOut(replacement);	×
NEW 173	statement.asCallable().call();	×
174	} finally {
175	System.setOut(originalOut);	×
176	}
177	String result = text.toString(currentDefaultCharset);	×
178	return result.replace(System.lineSeparator(), "\n");	×
179	}
180
181	private final class AntBuildListener extends DefaultLogger {
182	private AntBuildListener() {	×
183	msgOutputLevel = Project.MSG_INFO;	×
184	}	×
185
186	@Override
187	protected void printMessage(String message, PrintStream stream, int priority) {
188	log.append(message);	×
189	}	×
190
191	@Override
192	public void messageLogged(BuildEvent buildEvent) {
193	if (buildEvent.getPriority() <= Project.MSG_INFO) {	×
194	log.append(buildEvent.getMessage());	×
195	}
196	}	×
197	}
198	}

pmd / pmd / 830

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