#3787

pending completion

Build # #3787

Build Type

push

github actions

Committed by

oowekyala

Commit Message

add a test for display name in the cache

Run Details

67063 of 127681 relevant lines covered (52.52%)

0.53 hits per line

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

75.0

/pmd-core/src/main/java/net/sourceforge/pmd/cache/CachedRuleViolation.java

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

package net.sourceforge.pmd.cache;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;

import org.checkerframework.checker.nullness.qual.NonNull;

import net.sourceforge.pmd.Rule;
import net.sourceforge.pmd.RuleViolation;
import net.sourceforge.pmd.annotation.InternalApi;
import net.sourceforge.pmd.lang.document.FileLocation;
import net.sourceforge.pmd.lang.document.TextRange2d;
import net.sourceforge.pmd.util.StringUtil;

/**
 * A {@link RuleViolation} implementation that is immutable, and therefore cache friendly
 *
 * @deprecated This is internal API, will be hidden with 7.0.0
 */
@Deprecated
@InternalApi
public final class CachedRuleViolation implements RuleViolation {

    private final CachedRuleMapper mapper;

    private final String description;
    private final String ruleClassName;
    private final String ruleName;
    private final String ruleTargetLanguage;
    private final Map<String, String> additionalInfo;

    private FileLocation location;

    private CachedRuleViolation(final CachedRuleMapper mapper, final String description,
                                final String filePathId, final String ruleClassName, final String ruleName,
                                final String ruleTargetLanguage, final int beginLine, final int beginColumn,
                                final int endLine, final int endColumn,
                                final Map<String, String> additionalInfo) {
        this.mapper = mapper;
        this.description = description;
        this.location = FileLocation.range(filePathId, TextRange2d.range2d(beginLine, beginColumn, endLine, endColumn));
        this.ruleClassName = ruleClassName;
        this.ruleName = ruleName;
        this.ruleTargetLanguage = ruleTargetLanguage;
        this.additionalInfo = additionalInfo;
    }
    
    void setFileDisplayName(String displayName) {
        this.location = FileLocation.range(displayName,
                TextRange2d.range2d(getBeginLine(), getBeginColumn(), getEndLine(), getEndColumn()));
    }

    @Override
    public Rule getRule() {
        // The mapper may be initialized after cache is loaded, so use it lazily
        return mapper.getRuleForClass(ruleClassName, ruleName, ruleTargetLanguage);
    }

    @Override
    public String getDescription() {
        return description;
    }

    @Override
    public FileLocation getLocation() {
        return location;
    }

    @Override
    public Map<String, String> getAdditionalInfo() {
        return additionalInfo;
    }

    /**
     * Helper method to load a {@link CachedRuleViolation} from an input stream.
     *
     * @param stream The stream from which to load the violation.
     * @param filePathId The name of the file on which this rule was reported.
     * @param mapper The mapper to be used to obtain rule instances from the active rulesets.
     * @return The loaded rule violation.
     * @throws IOException
     */
    /* package */ static CachedRuleViolation loadFromStream(final DataInputStream stream,
            final String filePathId, final CachedRuleMapper mapper) throws IOException {
        final String description = stream.readUTF();
        final String ruleClassName = stream.readUTF();
        final String ruleName = stream.readUTF();
        final String ruleTargetLanguage = stream.readUTF();
        final int beginLine = stream.readInt();
        final int beginColumn = stream.readInt();
        final int endLine = stream.readInt();
        final int endColumn = stream.readInt();
        final Map<String, String> additionalInfo = readAdditionalInfo(stream);
        return new CachedRuleViolation(mapper, description, filePathId, ruleClassName, ruleName, ruleTargetLanguage,
                                       beginLine, beginColumn, endLine, endColumn, additionalInfo);
    }

    private static @NonNull Map<String, String> readAdditionalInfo(DataInputStream stream) throws IOException {
        int numAdditionalInfoKeyValuePairs = stream.readInt();
        if (numAdditionalInfoKeyValuePairs == 0) {
            return Collections.emptyMap();
        }

        Map<String, String> additionalInfo = new LinkedHashMap<>();
        while (numAdditionalInfoKeyValuePairs-- > 0) {
            final String key = stream.readUTF();
            final String value = stream.readUTF();
            additionalInfo.put(key, value);
        }
        return Collections.unmodifiableMap(additionalInfo);
    }

    /**
     * Helper method to store a {@link RuleViolation} in an output stream to be later
     * retrieved as a {@link CachedRuleViolation}
     *
     * @param stream    The stream on which to store the violation.
     * @param violation The rule violation to cache.
     */
    /* package */ static void storeToStream(final DataOutputStream stream,
            final RuleViolation violation) throws IOException {
        stream.writeUTF(StringUtil.nullToEmpty(violation.getDescription()));
        stream.writeUTF(StringUtil.nullToEmpty(violation.getRule().getRuleClass()));
        stream.writeUTF(StringUtil.nullToEmpty(violation.getRule().getName()));
        stream.writeUTF(StringUtil.nullToEmpty(violation.getRule().getLanguage().getTerseName()));
        FileLocation location = violation.getLocation();
        stream.writeInt(location.getStartPos().getLine());
        stream.writeInt(location.getStartPos().getColumn());
        stream.writeInt(location.getEndPos().getLine());
        stream.writeInt(location.getEndPos().getColumn());
        Map<String, String> additionalInfo = violation.getAdditionalInfo();
        stream.writeInt(additionalInfo.size());
        for (Entry<String, String> entry : additionalInfo.entrySet()) {
            stream.writeUTF(entry.getKey());
            stream.writeUTF(StringUtil.nullToEmpty(entry.getValue()));

        }
    }

}

1	/**
2	* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
3	*/
4
5	package net.sourceforge.pmd.cache;
6
7	import java.io.DataInputStream;
8	import java.io.DataOutputStream;
9	import java.io.IOException;
10	import java.util.Collections;
11	import java.util.LinkedHashMap;
12	import java.util.Map;
13	import java.util.Map.Entry;
14
15	import org.checkerframework.checker.nullness.qual.NonNull;
16
17	import net.sourceforge.pmd.Rule;
18	import net.sourceforge.pmd.RuleViolation;
19	import net.sourceforge.pmd.annotation.InternalApi;
20	import net.sourceforge.pmd.lang.document.FileLocation;
21	import net.sourceforge.pmd.lang.document.TextRange2d;
22	import net.sourceforge.pmd.util.StringUtil;
23
24	/**
25	* A {@link RuleViolation} implementation that is immutable, and therefore cache friendly
26	*
27	* @deprecated This is internal API, will be hidden with 7.0.0
28	*/
29	@Deprecated
30	@InternalApi
31	public final class CachedRuleViolation implements RuleViolation {
32
33	private final CachedRuleMapper mapper;
34
35	private final String description;
36	private final String ruleClassName;
37	private final String ruleName;
38	private final String ruleTargetLanguage;
39	private final Map<String, String> additionalInfo;
40
41	private FileLocation location;
42
43	private CachedRuleViolation(final CachedRuleMapper mapper, final String description,
44	final String filePathId, final String ruleClassName, final String ruleName,
45	final String ruleTargetLanguage, final int beginLine, final int beginColumn,
46	final int endLine, final int endColumn,
47	final Map<String, String> additionalInfo) {	1✔
48	this.mapper = mapper;	1✔
49	this.description = description;	1✔
50	this.location = FileLocation.range(filePathId, TextRange2d.range2d(beginLine, beginColumn, endLine, endColumn));	1✔
51	this.ruleClassName = ruleClassName;	1✔
52	this.ruleName = ruleName;	1✔
53	this.ruleTargetLanguage = ruleTargetLanguage;	1✔
54	this.additionalInfo = additionalInfo;	1✔
55	}	1✔
56
57	void setFileDisplayName(String displayName) {
58	this.location = FileLocation.range(displayName,	1✔
59	TextRange2d.range2d(getBeginLine(), getBeginColumn(), getEndLine(), getEndColumn()));	1✔
60	}	1✔
61
62	@Override
63	public Rule getRule() {
64	// The mapper may be initialized after cache is loaded, so use it lazily
65	return mapper.getRuleForClass(ruleClassName, ruleName, ruleTargetLanguage);	×
66	}
67
68	@Override
69	public String getDescription() {
70	return description;	×
71	}
72
73	@Override
74	public FileLocation getLocation() {
75	return location;	1✔
76	}
77
78	@Override
79	public Map<String, String> getAdditionalInfo() {
80	return additionalInfo;	×
81	}
82
83	/**
84	* Helper method to load a {@link CachedRuleViolation} from an input stream.
85	*
86	* @param stream The stream from which to load the violation.
87	* @param filePathId The name of the file on which this rule was reported.
88	* @param mapper The mapper to be used to obtain rule instances from the active rulesets.
89	* @return The loaded rule violation.
90	* @throws IOException
91	*/
92	/* package */ static CachedRuleViolation loadFromStream(final DataInputStream stream,
93	final String filePathId, final CachedRuleMapper mapper) throws IOException {
94	final String description = stream.readUTF();	1✔
95	final String ruleClassName = stream.readUTF();	1✔
96	final String ruleName = stream.readUTF();	1✔
97	final String ruleTargetLanguage = stream.readUTF();	1✔
98	final int beginLine = stream.readInt();	1✔
99	final int beginColumn = stream.readInt();	1✔
100	final int endLine = stream.readInt();	1✔
101	final int endColumn = stream.readInt();	1✔
102	final Map<String, String> additionalInfo = readAdditionalInfo(stream);	1✔
103	return new CachedRuleViolation(mapper, description, filePathId, ruleClassName, ruleName, ruleTargetLanguage,	1✔
104	beginLine, beginColumn, endLine, endColumn, additionalInfo);
105	}
106
107	private static @NonNull Map<String, String> readAdditionalInfo(DataInputStream stream) throws IOException {
108	int numAdditionalInfoKeyValuePairs = stream.readInt();	1✔
109	if (numAdditionalInfoKeyValuePairs == 0) {	1✔
110	return Collections.emptyMap();	1✔
111	}
112
113	Map<String, String> additionalInfo = new LinkedHashMap<>();	×
114	while (numAdditionalInfoKeyValuePairs-- > 0) {	×
115	final String key = stream.readUTF();	×
116	final String value = stream.readUTF();	×
117	additionalInfo.put(key, value);	×
118	}	×
119	return Collections.unmodifiableMap(additionalInfo);	×
120	}
121
122	/**
123	* Helper method to store a {@link RuleViolation} in an output stream to be later
124	* retrieved as a {@link CachedRuleViolation}
125	*
126	* @param stream The stream on which to store the violation.
127	* @param violation The rule violation to cache.
128	*/
129	/* package */ static void storeToStream(final DataOutputStream stream,
130	final RuleViolation violation) throws IOException {
131	stream.writeUTF(StringUtil.nullToEmpty(violation.getDescription()));	1✔
132	stream.writeUTF(StringUtil.nullToEmpty(violation.getRule().getRuleClass()));	1✔
133	stream.writeUTF(StringUtil.nullToEmpty(violation.getRule().getName()));	1✔
134	stream.writeUTF(StringUtil.nullToEmpty(violation.getRule().getLanguage().getTerseName()));	1✔
135	FileLocation location = violation.getLocation();	1✔
136	stream.writeInt(location.getStartPos().getLine());	1✔
137	stream.writeInt(location.getStartPos().getColumn());	1✔
138	stream.writeInt(location.getEndPos().getLine());	1✔
139	stream.writeInt(location.getEndPos().getColumn());	1✔
140	Map<String, String> additionalInfo = violation.getAdditionalInfo();	1✔
141	stream.writeInt(additionalInfo.size());	1✔
142	for (Entry<String, String> entry : additionalInfo.entrySet()) {	1✔
143	stream.writeUTF(entry.getKey());	×
144	stream.writeUTF(StringUtil.nullToEmpty(entry.getValue()));	×
145
146	}	×
147	}	1✔
148
149	}

pmd / pmd / #3787

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