private static void validateAnalyzerMessage(
Map<IssueAttribute, String> attrs, AnalyzerMessage analyzerMessage) {
Double effortToFix = analyzerMessage.getCost();
if (effortToFix != null) {
assertEquals(Integer.toString(effortToFix.intValue()), attrs, IssueAttribute.EFFORT_TO_FIX);
}
AnalyzerMessage.TextSpan textSpan = analyzerMessage.primaryLocation();
assertEquals(normalizeColumn(textSpan.startCharacter), attrs, IssueAttribute.START_COLUMN);
assertEquals(Integer.toString(textSpan.endLine), attrs, IssueAttribute.END_LINE);
assertEquals(normalizeColumn(textSpan.endCharacter), attrs, IssueAttribute.END_COLUMN);
if (attrs.containsKey(IssueAttribute.SECONDARY_LOCATIONS)) {
List<AnalyzerMessage> secondaryLocations = analyzerMessage.secondaryLocations;
Multiset<String> actualLines = HashMultiset.create();
for (AnalyzerMessage secondaryLocation : secondaryLocations) {
actualLines.add(Integer.toString(secondaryLocation.getLine()));
}
List<String> expected =
Lists.newArrayList(
Splitter.on(",")
.omitEmptyStrings()
.trimResults()
.split(attrs.get(IssueAttribute.SECONDARY_LOCATIONS)));
List<String> unexpected = new ArrayList<>();
for (String actualLine : actualLines) {
if (expected.contains(actualLine)) {
expected.remove(actualLine);
} else {
unexpected.add(actualLine);
}
}
if (!expected.isEmpty() || !unexpected.isEmpty()) {
Fail.fail("Secondary locations: expected: " + expected + " unexpected:" + unexpected);
}
}
}
private static void updateEndLine(int expectedLine, EnumMap<IssueAttribute, String> attr) {
if (attr.containsKey(IssueAttribute.END_LINE)) {
String endLineStr = attr.get(IssueAttribute.END_LINE);
if (endLineStr.charAt(0) == '+') {
int endLine = Integer.parseInt(endLineStr);
attr.put(IssueAttribute.END_LINE, Integer.toString(expectedLine + endLine));
} else {
Fail.fail("endLine attribute should be relative to the line and must be +N with N integer");
}
}
}
@Test(expected = NullPointerException.class)
public void shouldNotAcceptNullValues() {
// given
SmallMap<String, Integer> newSmallMap = SmallMap.newSmallMap();
// when
newSmallMap.put("abc", null);
// then
Fail.fail("NullPointerException expected");
}
private static String extractAttributes(String comment, Map<IssueAttribute, String> attr) {
String attributesSubstr = StringUtils.substringBetween(comment, "[[", "]]");
if (!StringUtils.isEmpty(attributesSubstr)) {
Iterable<String> attributes = Splitter.on(";").split(attributesSubstr);
for (String attribute : attributes) {
String[] split = StringUtils.split(attribute, '=');
if (split.length == 2 && CheckVerifier.ATTRIBUTE_MAP.containsKey(split[0])) {
attr.put(CheckVerifier.ATTRIBUTE_MAP.get(split[0]), split[1]);
} else {
Fail.fail("// Noncompliant attributes not valid: " + attributesSubstr);
}
}
}
return attributesSubstr;
}
@Test
public void loadInto_FromNonClassPath() {
// prepare
Load01 cfg = new Load01();
// execute
TestConfigurationBuilder sut =
TestConfigurationBuilder.buildTestConfig().sourcePath("/other/path");
try {
sut.loadInto(cfg);
Fail.fail();
} catch (IllegalArgumentException e) {
assertThat(e).hasMessage("currently only classpath: is a supported location");
}
}
@Test
public void shouldNotAcceptnInvalidGroup() {
// given
Agent underTest = null;
String invalidValue = null;
// when
try {
underTest = new Agent(1, "", "", 1, invalidValue);
Fail.fail("IllegalArgumentException expected");
} catch (IllegalArgumentException e) {
// then
assertThat(underTest).isNull();
}
}
@Test
public void shouldNotAcceptInvalidLastCheck() {
// given
Agent underTest = null;
int invalidValue = -1;
// when
try {
underTest = new Agent(1, "", "", invalidValue, "");
Fail.fail("IllegalArgumentException expected");
} catch (IllegalArgumentException e) {
// then
assertThat(underTest).isNull();
}
}
private void assertMultipleIssue(Set<AnalyzerMessage> issues) throws AssertionError {
Preconditions.checkState(!issues.isEmpty(), "At least one issue expected");
List<Integer> unexpectedLines = Lists.newLinkedList();
boolean isLinear = isLinear(issues.iterator().next());
for (AnalyzerMessage issue : issues) {
validateIssue(expected, unexpectedLines, issue, isLinear);
}
if (!expected.isEmpty() || !unexpectedLines.isEmpty()) {
Collections.sort(unexpectedLines);
String expectedMsg = !expected.isEmpty() ? ("Expected " + expected) : "";
String unexpectedMsg =
!unexpectedLines.isEmpty()
? ((expectedMsg.isEmpty() ? "" : ", ") + "Unexpected at " + unexpectedLines)
: "";
Fail.fail(expectedMsg + unexpectedMsg);
}
}
private static void validateIssue(
Multimap<Integer, Map<IssueAttribute, String>> expected,
List<Integer> unexpectedLines,
AnalyzerMessage issue,
boolean isLinear) {
int line = issue.getLine();
if (expected.containsKey(line)) {
Map<IssueAttribute, String> attrs = Iterables.getLast(expected.get(line));
assertEquals(issue.getMessage(), attrs, IssueAttribute.MESSAGE);
Double cost = issue.getCost();
if (cost != null) {
assertEquals(Integer.toString(cost.intValue()), attrs, IssueAttribute.EFFORT_TO_FIX);
} else if (isLinear) {
Fail.fail("A cost should be provided for a rule with linear remediation function");
}
validateAnalyzerMessage(attrs, issue);
expected.remove(line, attrs);
} else {
unexpectedLines.add(line);
}
}
protected void collectExpectedIssues(String comment, int line) {
String expectedStart = getExpectedIssueTrigger();
if (comment.startsWith(expectedStart)) {
String cleanedComment = StringUtils.remove(comment, expectedStart);
EnumMap<IssueAttribute, String> attr = new EnumMap<>(IssueAttribute.class);
String expectedMessage = StringUtils.substringBetween(cleanedComment, "{{", "}}");
if (StringUtils.isNotEmpty(expectedMessage)) {
attr.put(IssueAttribute.MESSAGE, expectedMessage);
}
int expectedLine = line;
String attributesSubstr = extractAttributes(comment, attr);
cleanedComment =
StringUtils.stripEnd(
StringUtils.remove(
StringUtils.remove(cleanedComment, "[[" + attributesSubstr + "]]"),
"{{" + expectedMessage + "}}"),
" \t");
if (StringUtils.startsWith(cleanedComment, "@")) {
final int lineAdjustment;
final char firstChar = cleanedComment.charAt(1);
final int endIndex = cleanedComment.indexOf(' ');
if (endIndex == -1) {
lineAdjustment = Integer.parseInt(cleanedComment.substring(2));
} else {
lineAdjustment = Integer.parseInt(cleanedComment.substring(2, endIndex));
}
if (firstChar == '+') {
expectedLine += lineAdjustment;
} else if (firstChar == '-') {
expectedLine -= lineAdjustment;
} else {
Fail.fail("Use only '@+N' or '@-N' to shifts messages.");
}
}
updateEndLine(expectedLine, attr);
expected.put(expectedLine, attr);
}
}