/*
* Copyright 2000-2014 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.intellij.testFramework;
import com.intellij.codeHighlighting.Pass;
import com.intellij.codeInsight.daemon.LineMarkerInfo;
import com.intellij.codeInsight.daemon.impl.HighlightInfo;
import com.intellij.codeInsight.daemon.impl.HighlightInfoType;
import com.intellij.codeInsight.daemon.impl.SeveritiesProvider;
import com.intellij.lang.annotation.HighlightSeverity;
import com.intellij.openapi.application.Result;
import com.intellij.openapi.command.WriteCommandAction;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.editor.Document;
import com.intellij.openapi.editor.HighlighterColors;
import com.intellij.openapi.editor.RangeMarker;
import com.intellij.openapi.editor.colors.TextAttributesKey;
import com.intellij.openapi.editor.markup.EffectType;
import com.intellij.openapi.editor.markup.GutterIconRenderer;
import com.intellij.openapi.editor.markup.TextAttributes;
import com.intellij.openapi.extensions.Extensions;
import com.intellij.openapi.util.*;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiFile;
import com.intellij.util.ConstantFunction;
import com.intellij.util.FileComparisonFailure;
import com.intellij.util.Function;
import com.intellij.util.NullableFunction;
import com.intellij.util.containers.ContainerUtil;
import gnu.trove.THashMap;
import gnu.trove.THashSet;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.junit.Assert;
import java.awt.*;
import java.lang.reflect.Field;
import java.util.*;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* @author cdr
*/
public class ExpectedHighlightingData {
private static final Logger LOG = Logger.getInstance("#com.intellij.testFramework.ExpectedHighlightingData");
@NonNls private static final String ERROR_MARKER = "error";
@NonNls private static final String WARNING_MARKER = "warning";
@NonNls private static final String WEAK_WARNING_MARKER = "weak_warning";
@NonNls private static final String INFO_MARKER = "info";
@NonNls private static final String END_LINE_HIGHLIGHT_MARKER = "EOLError";
@NonNls private static final String END_LINE_WARNING_MARKER = "EOLWarning";
@NonNls private static final String LINE_MARKER = "lineMarker";
@NotNull private final Document myDocument;
private final PsiFile myFile;
@NonNls private static final String ANY_TEXT = "*";
private final String myText;
public static class ExpectedHighlightingSet {
private final HighlightSeverity severity;
private final boolean endOfLine;
private final boolean enabled;
private final Set<HighlightInfo> infos;
public ExpectedHighlightingSet(@NotNull HighlightSeverity severity, boolean endOfLine, boolean enabled) {
this.severity = severity;
this.endOfLine = endOfLine;
this.enabled = enabled;
infos = new THashSet<HighlightInfo>();
}
}
@SuppressWarnings("WeakerAccess")
protected final Map<String,ExpectedHighlightingSet> highlightingTypes;
private final Map<RangeMarker, LineMarkerInfo> lineMarkerInfos = new THashMap<RangeMarker, LineMarkerInfo>();
public void init() {
new WriteCommandAction(null){
@Override
protected void run(@NotNull Result result) throws Throwable {
extractExpectedLineMarkerSet(myDocument);
extractExpectedHighlightsSet(myDocument);
refreshLineMarkers();
}
}.execute();
}
public ExpectedHighlightingData(@NotNull Document document,boolean checkWarnings, boolean checkInfos) {
this(document, checkWarnings, false, checkInfos);
}
public ExpectedHighlightingData(@NotNull Document document,
boolean checkWarnings,
boolean checkWeakWarnings,
boolean checkInfos) {
this(document, checkWarnings, checkWeakWarnings, checkInfos, null);
}
public ExpectedHighlightingData(@NotNull final Document document, PsiFile file) {
myDocument = document;
myFile = file;
myText = document.getText();
highlightingTypes = new LinkedHashMap<String, ExpectedHighlightingSet>();
new WriteCommandAction.Simple(file == null ? null : file.getProject()) {
public void run() {
boolean checkWarnings = false;
boolean checkWeakWarnings = false;
boolean checkInfos = false;
highlightingTypes.put(ERROR_MARKER, new ExpectedHighlightingSet(HighlightSeverity.ERROR, false, true));
highlightingTypes.put(WARNING_MARKER, new ExpectedHighlightingSet(HighlightSeverity.WARNING, false, checkWarnings));
highlightingTypes.put(WEAK_WARNING_MARKER, new ExpectedHighlightingSet(HighlightSeverity.WEAK_WARNING, false, checkWeakWarnings));
highlightingTypes.put("inject", new ExpectedHighlightingSet(HighlightInfoType.INJECTED_FRAGMENT_SEVERITY, false, checkInfos));
highlightingTypes.put(INFO_MARKER, new ExpectedHighlightingSet(HighlightSeverity.INFORMATION, false, checkInfos));
highlightingTypes.put("symbolName", new ExpectedHighlightingSet(HighlightInfoType.SYMBOL_TYPE_SEVERITY, false, false));
for (SeveritiesProvider provider : Extensions.getExtensions(SeveritiesProvider.EP_NAME)) {
for (HighlightInfoType type : provider.getSeveritiesHighlightInfoTypes()) {
final HighlightSeverity severity = type.getSeverity(null);
highlightingTypes.put(severity.getName(), new ExpectedHighlightingSet(severity, false, true));
}
}
highlightingTypes.put(END_LINE_HIGHLIGHT_MARKER, new ExpectedHighlightingSet(HighlightSeverity.ERROR, true, true));
highlightingTypes.put(END_LINE_WARNING_MARKER, new ExpectedHighlightingSet(HighlightSeverity.WARNING, true, checkWarnings));
initAdditionalHighlightingTypes();
}
}.execute().throwException();
}
public ExpectedHighlightingData(@NotNull final Document document,
final boolean checkWarnings,
final boolean checkWeakWarnings,
final boolean checkInfos,
@Nullable final PsiFile file) {
this(document, file);
if (checkWarnings) checkWarnings();
if (checkWeakWarnings) checkWeakWarnings();
if (checkInfos) checkInfos();
}
public void checkWarnings() {
highlightingTypes.put(WARNING_MARKER, new ExpectedHighlightingSet(HighlightSeverity.WARNING, false, true));
highlightingTypes.put(END_LINE_WARNING_MARKER, new ExpectedHighlightingSet(HighlightSeverity.WARNING, true, true));
}
public void checkWeakWarnings() {
highlightingTypes.put(WEAK_WARNING_MARKER, new ExpectedHighlightingSet(HighlightSeverity.WEAK_WARNING, false, true));
}
public void checkInfos() {
highlightingTypes.put(INFO_MARKER, new ExpectedHighlightingSet(HighlightSeverity.INFORMATION, false, true));
highlightingTypes.put("inject", new ExpectedHighlightingSet(HighlightInfoType.INJECTED_FRAGMENT_SEVERITY, false, true));
}
public void checkSymbolNames() {
highlightingTypes.put("symbolName", new ExpectedHighlightingSet(HighlightInfoType.SYMBOL_TYPE_SEVERITY, false, true));
}
private void refreshLineMarkers() {
for (Map.Entry<RangeMarker, LineMarkerInfo> entry : lineMarkerInfos.entrySet()) {
RangeMarker rangeMarker = entry.getKey();
int startOffset = rangeMarker.getStartOffset();
int endOffset = rangeMarker.getEndOffset();
final LineMarkerInfo value = entry.getValue();
LineMarkerInfo markerInfo = new LineMarkerInfo<PsiElement>(value.getElement(), new TextRange(startOffset,endOffset), null, value.updatePass, new Function<PsiElement,String>() {
@Override
public String fun(PsiElement psiElement) {
return value.getLineMarkerTooltip();
}
}, null, GutterIconRenderer.Alignment.RIGHT);
entry.setValue(markerInfo);
}
}
private void extractExpectedLineMarkerSet(Document document) {
String text = document.getText();
@NonNls String pat = ".*?((<" + LINE_MARKER + ")(?: descr=\"((?:[^\"\\\\]|\\\\\")*)\")?>)(.*)";
final Pattern p = Pattern.compile(pat, Pattern.DOTALL);
final Pattern pat2 = Pattern.compile("(.*?)(</" + LINE_MARKER + ">)(.*)", Pattern.DOTALL);
while (true) {
Matcher m = p.matcher(text);
if (!m.matches()) break;
int startOffset = m.start(1);
final String descr = m.group(3) != null ? m.group(3) : ANY_TEXT;
String rest = m.group(4);
document.replaceString(startOffset, m.end(1), "");
final Matcher matcher2 = pat2.matcher(rest);
LOG.assertTrue(matcher2.matches(), "Cannot find closing </" + LINE_MARKER + ">");
String content = matcher2.group(1);
int endOffset = startOffset + matcher2.start(3);
String endTag = matcher2.group(2);
document.replaceString(startOffset, endOffset, content);
endOffset -= endTag.length();
LineMarkerInfo markerInfo = new LineMarkerInfo<PsiElement>(myFile, new TextRange(startOffset, endOffset), null, Pass.LINE_MARKERS,
new ConstantFunction<PsiElement, String>(descr), null,
GutterIconRenderer.Alignment.RIGHT);
lineMarkerInfos.put(document.createRangeMarker(startOffset, endOffset), markerInfo);
text = document.getText();
}
}
/**
* Override in order to register special highlighting
*/
protected void initAdditionalHighlightingTypes() {}
/**
* remove highlights (bounded with <marker>...</marker>) from test case file
* @param document document to process
*/
private void extractExpectedHighlightsSet(final Document document) {
final String text = document.getText();
final Set<String> markers = highlightingTypes.keySet();
final String typesRx = "(?:" + StringUtil.join(markers, ")|(?:") + ")";
final String openingTagRx = "<(" + typesRx + ")" +
"(?:\\s+descr=\"((?:[^\"]|\\\\\"|\\\\\\\\\"|\\\\\\[|\\\\\\])*)\")?" +
"(?:\\s+type=\"([0-9A-Z_]+)\")?" +
"(?:\\s+foreground=\"([0-9xa-f]+)\")?" +
"(?:\\s+background=\"([0-9xa-f]+)\")?" +
"(?:\\s+effectcolor=\"([0-9xa-f]+)\")?" +
"(?:\\s+effecttype=\"([A-Z]+)\")?" +
"(?:\\s+fonttype=\"([0-9]+)\")?" +
"(?:\\s+textAttributesKey=\"((?:[^\"]|\\\\\"|\\\\\\\\\"|\\\\\\[|\\\\\\])*)\")?" +
"(/)?>";
final Matcher matcher = Pattern.compile(openingTagRx).matcher(text);
int pos = 0;
final Ref<Integer> textOffset = Ref.create(0);
while (matcher.find(pos)) {
textOffset.set(textOffset.get() + matcher.start() - pos);
pos = extractExpectedHighlight(matcher, text, document, textOffset);
}
}
private int extractExpectedHighlight(final Matcher matcher, final String text, final Document document, final Ref<Integer> textOffset) {
document.deleteString(textOffset.get(), textOffset.get() + matcher.end() - matcher.start());
int groupIdx = 1;
final String marker = matcher.group(groupIdx++);
@NonNls String descr = matcher.group(groupIdx++);
final String typeString = matcher.group(groupIdx++);
final String foregroundColor = matcher.group(groupIdx++);
final String backgroundColor = matcher.group(groupIdx++);
final String effectColor = matcher.group(groupIdx++);
final String effectType = matcher.group(groupIdx++);
final String fontType = matcher.group(groupIdx++);
final String attrKey = matcher.group(groupIdx++);
final boolean closed = matcher.group(groupIdx) != null;
if (descr == null) {
descr = ANY_TEXT; // no descr means any string by default
}
else if (descr.equals("null")) {
descr = null; // explicit "null" descr
}
if (descr != null) {
descr = descr.replaceAll("\\\\\\\\\"", "\""); // replace: \\" to ", doesn't check symbol before sequence \\"
}
HighlightInfoType type = WHATEVER;
if (typeString != null) {
try {
Field field = HighlightInfoType.class.getField(typeString);
type = (HighlightInfoType)field.get(null);
}
catch (Exception e) {
LOG.error(e);
}
LOG.assertTrue(type != null, "Wrong highlight type: " + typeString);
}
TextAttributes forcedAttributes = null;
if (foregroundColor != null) {
//noinspection MagicConstant
forcedAttributes = new TextAttributes(Color.decode(foregroundColor), Color.decode(backgroundColor), Color.decode(effectColor),
EffectType.valueOf(effectType), Integer.parseInt(fontType));
}
final int rangeStart = textOffset.get();
final int toContinueFrom;
if (closed) {
toContinueFrom = matcher.end();
}
else {
int pos = matcher.end();
final Matcher closingTagMatcher = Pattern.compile("</" + marker + ">").matcher(text);
while (true) {
if (!closingTagMatcher.find(pos)) {
LOG.error("Cannot find closing </" + marker + "> in position " + pos);
}
final int nextTagStart = matcher.find(pos) ? matcher.start() : text.length();
if (closingTagMatcher.start() < nextTagStart) {
textOffset.set(textOffset.get() + closingTagMatcher.start() - pos);
document.deleteString(textOffset.get(), textOffset.get() + closingTagMatcher.end() - closingTagMatcher.start());
toContinueFrom = closingTagMatcher.end();
break;
}
textOffset.set(textOffset.get() + nextTagStart - pos);
pos = extractExpectedHighlight(matcher, text, document, textOffset);
}
}
final ExpectedHighlightingSet expectedHighlightingSet = highlightingTypes.get(marker);
if (expectedHighlightingSet.enabled) {
TextAttributesKey forcedTextAttributesKey = attrKey == null ? null : TextAttributesKey.createTextAttributesKey(attrKey);
HighlightInfo.Builder builder =
HighlightInfo.newHighlightInfo(type).range(rangeStart, textOffset.get()).severity(expectedHighlightingSet.severity);
if (forcedAttributes != null) builder.textAttributes(forcedAttributes);
if (forcedTextAttributesKey != null) builder.textAttributes(forcedTextAttributesKey);
if (descr != null) { builder.description(descr); builder.unescapedToolTip(descr); }
if (expectedHighlightingSet.endOfLine) builder.endOfLine();
HighlightInfo highlightInfo = builder.createUnconditionally();
expectedHighlightingSet.infos.add(highlightInfo);
}
return toContinueFrom;
}
private static final HighlightInfoType WHATEVER = new HighlightInfoType.HighlightInfoTypeImpl(HighlightSeverity.INFORMATION,
HighlighterColors.TEXT);
public void checkLineMarkers(Collection<LineMarkerInfo> markerInfos, String text) {
String fileName = myFile == null ? "" : myFile.getName() + ": ";
String failMessage = "";
if (markerInfos != null) {
for (LineMarkerInfo info : markerInfos) {
if (!containsLineMarker(info, lineMarkerInfos.values())) {
final int startOffset = info.startOffset;
final int endOffset = info.endOffset;
int y1 = StringUtil.offsetToLineNumber(text, startOffset);
int y2 = StringUtil.offsetToLineNumber(text, endOffset);
int x1 = startOffset - StringUtil.lineColToOffset(text, y1, 0);
int x2 = endOffset - StringUtil.lineColToOffset(text, y2, 0);
if (!failMessage.isEmpty()) failMessage += '\n';
failMessage += fileName + "Extra line marker highlighted " +
"(" + (x1 + 1) + ", " + (y1 + 1) + ")" + "-" +
"(" + (x2 + 1) + ", " + (y2 + 1) + ")"
+ ": '"+info.getLineMarkerTooltip()+"'"
;
}
}
}
for (LineMarkerInfo expectedLineMarker : lineMarkerInfos.values()) {
if (markerInfos != null && !containsLineMarker(expectedLineMarker, markerInfos)) {
final int startOffset = expectedLineMarker.startOffset;
final int endOffset = expectedLineMarker.endOffset;
int y1 = StringUtil.offsetToLineNumber(text, startOffset);
int y2 = StringUtil.offsetToLineNumber(text, endOffset);
int x1 = startOffset - StringUtil.lineColToOffset(text, y1, 0);
int x2 = endOffset - StringUtil.lineColToOffset(text, y2, 0);
if (!failMessage.isEmpty()) failMessage += '\n';
failMessage += fileName + "Line marker was not highlighted " +
"(" + (x1 + 1) + ", " + (y1 + 1) + ")" + "-" +
"(" + (x2 + 1) + ", " + (y2 + 1) + ")"
+ ": '"+expectedLineMarker.getLineMarkerTooltip()+"'"
;
}
}
if (!failMessage.isEmpty()) Assert.fail(failMessage);
}
private static boolean containsLineMarker(LineMarkerInfo info, Collection<LineMarkerInfo> where) {
final String infoTooltip = info.getLineMarkerTooltip();
for (LineMarkerInfo markerInfo : where) {
String markerInfoTooltip;
if (markerInfo.startOffset == info.startOffset &&
markerInfo.endOffset == info.endOffset &&
( Comparing.equal(infoTooltip, markerInfoTooltip = markerInfo.getLineMarkerTooltip()) ||
ANY_TEXT.equals(markerInfoTooltip) ||
ANY_TEXT.equals(infoTooltip)
)
) {
return true;
}
}
return false;
}
public void checkResult(Collection<HighlightInfo> infos, String text) {
checkResult(infos, text, null);
}
public void checkResult(Collection<HighlightInfo> infos, String text, @Nullable String filePath) {
if (filePath == null) {
VirtualFile virtualFile = myFile == null? null : myFile.getVirtualFile();
filePath = virtualFile == null? null : virtualFile.getUserData(VfsTestUtil.TEST_DATA_FILE_PATH);
}
String fileName = myFile == null ? "" : myFile.getName() + ": ";
String failMessage = "";
for (HighlightInfo info : reverseCollection(infos)) {
if (!expectedInfosContainsInfo(info)) {
final int startOffset = info.startOffset;
final int endOffset = info.endOffset;
String s = text.substring(startOffset, endOffset);
String desc = info.getDescription();
int y1 = StringUtil.offsetToLineNumber(text, startOffset);
int y2 = StringUtil.offsetToLineNumber(text, endOffset);
int x1 = startOffset - StringUtil.lineColToOffset(text, y1, 0);
int x2 = endOffset - StringUtil.lineColToOffset(text, y2, 0);
if (!failMessage.isEmpty()) failMessage += '\n';
failMessage += fileName + "Extra text fragment highlighted " +
"(" + (x1 + 1) + ", " + (y1 + 1) + ")" + "-" +
"(" + (x2 + 1) + ", " + (y2 + 1) + ")" +
" :'" +
s +
"'" + (desc == null ? "" : " (" + desc + ")")
+ " [" + info.type + "]";
}
}
final Collection<ExpectedHighlightingSet> expectedHighlights = highlightingTypes.values();
for (ExpectedHighlightingSet highlightingSet : reverseCollection(expectedHighlights)) {
final Set<HighlightInfo> expInfos = highlightingSet.infos;
for (HighlightInfo expectedInfo : expInfos) {
if (!infosContainsExpectedInfo(infos, expectedInfo) && highlightingSet.enabled) {
final int startOffset = expectedInfo.startOffset;
final int endOffset = expectedInfo.endOffset;
String s = text.substring(startOffset, endOffset);
String desc = expectedInfo.getDescription();
int y1 = StringUtil.offsetToLineNumber(text, startOffset);
int y2 = StringUtil.offsetToLineNumber(text, endOffset);
int x1 = startOffset - StringUtil.lineColToOffset(text, y1, 0);
int x2 = endOffset - StringUtil.lineColToOffset(text, y2, 0);
if (!failMessage.isEmpty()) failMessage += '\n';
failMessage += fileName + "Text fragment was not highlighted " +
"(" + (x1 + 1) + ", " + (y1 + 1) + ")" + "-" +
"(" + (x2 + 1) + ", " + (y2 + 1) + ")" +
" :'" +
s +
"'" + (desc == null ? "" : " (" + desc + ")");
}
}
}
if (!failMessage.isEmpty()) {
compareTexts(infos, text, failMessage + "\n", filePath);
}
}
private static <T> List<T> reverseCollection(Collection<T> infos) {
return ContainerUtil.reverse(infos instanceof List ? (List<T>)infos : new ArrayList<T>(infos));
}
private void compareTexts(Collection<HighlightInfo> infos, String text, String failMessage, @Nullable String filePath) {
String actual = composeText(highlightingTypes, infos, text);
if (filePath != null && !myText.equals(actual)) {
// uncomment to overwrite, don't forget to revert on commit!
//VfsTestUtil.overwriteTestData(filePath, actual);
//return;
throw new FileComparisonFailure(failMessage, myText, actual, filePath);
}
Assert.assertEquals(failMessage + "\n", myText, actual);
Assert.fail(failMessage);
}
public static String composeText(final Map<String, ExpectedHighlightingSet> types, Collection<HighlightInfo> infos, String text) {
// filter highlighting data and map each highlighting to a tag name
List<Pair<String, HighlightInfo>> list = ContainerUtil.mapNotNull(infos, new NullableFunction<HighlightInfo, Pair<String,HighlightInfo>>() {
@Override
public Pair<String, HighlightInfo> fun(HighlightInfo info) {
for (Map.Entry<String, ExpectedHighlightingSet> entry : types.entrySet()) {
final ExpectedHighlightingSet set = entry.getValue();
if (set.enabled && set.severity == info.getSeverity() && set.endOfLine == info.isAfterEndOfLine()) {
return Pair.create(entry.getKey(), info);
}
}
return null;
}
});
// sort filtered highlighting data by end offset in descending order
Collections.sort(list, new Comparator<Pair<String, HighlightInfo>>() {
@Override
public int compare(Pair<String, HighlightInfo> o1, Pair<String, HighlightInfo> o2) {
HighlightInfo i1 = o1.second;
HighlightInfo i2 = o2.second;
int byEnds = i2.endOffset - i1.endOffset;
if (byEnds != 0) return byEnds;
if (!i1.isAfterEndOfLine() && !i2.isAfterEndOfLine()) {
int byStarts = i1.startOffset - i2.startOffset;
if (byStarts != 0) return byStarts;
}
else {
int byEOL = Comparing.compare(i2.isAfterEndOfLine(), i1.isAfterEndOfLine());
if (byEOL != 0) return byEOL;
}
int bySeverity = i2.getSeverity().compareTo(i1.getSeverity());
if (bySeverity != 0) return bySeverity;
return Comparing.compare(i1.getDescription(), i2.getDescription());
}
});
// combine highlighting data with original text
StringBuilder sb = new StringBuilder();
Couple<Integer> result = composeText(sb, list, 0, text, text.length(), 0);
sb.insert(0, text.substring(0, result.second));
return sb.toString();
}
private static Couple<Integer> composeText(StringBuilder sb,
List<Pair<String, HighlightInfo>> list, int index,
String text, int endPos, int startPos) {
int i = index;
while (i < list.size()) {
Pair<String, HighlightInfo> pair = list.get(i);
HighlightInfo info = pair.second;
if (info.endOffset <= startPos) {
break;
}
String severity = pair.first;
HighlightInfo prev = i < list.size() - 1 ? list.get(i + 1).second : null;
sb.insert(0, text.substring(info.endOffset, endPos));
sb.insert(0, "</" + severity + ">");
endPos = info.endOffset;
if (prev != null && prev.endOffset > info.startOffset) {
Couple<Integer> result = composeText(sb, list, i + 1, text, endPos, info.startOffset);
i = result.first - 1;
endPos = result.second;
}
sb.insert(0, text.substring(info.startOffset, endPos));
sb.insert(0, "<" + severity + " descr=\"" + info.getDescription() + "\">");
endPos = info.startOffset;
i++;
}
return Couple.of(i, endPos);
}
private static boolean infosContainsExpectedInfo(Collection<HighlightInfo> infos, HighlightInfo expectedInfo) {
for (HighlightInfo info : infos) {
if (infoEquals(expectedInfo, info)) {
return true;
}
}
return false;
}
private boolean expectedInfosContainsInfo(HighlightInfo info) {
if (info.getTextAttributes(null, null) == TextAttributes.ERASE_MARKER) return true;
final Collection<ExpectedHighlightingSet> expectedHighlights = highlightingTypes.values();
for (ExpectedHighlightingSet highlightingSet : expectedHighlights) {
if (highlightingSet.severity != info.getSeverity()) continue;
if (!highlightingSet.enabled) return true;
final Set<HighlightInfo> infos = highlightingSet.infos;
for (HighlightInfo expectedInfo : infos) {
if (infoEquals(expectedInfo, info)) {
return true;
}
}
}
return false;
}
private static boolean infoEquals(HighlightInfo expectedInfo, HighlightInfo info) {
if (expectedInfo == info) return true;
return
info.getSeverity() == expectedInfo.getSeverity() &&
info.startOffset == expectedInfo.startOffset &&
info.endOffset == expectedInfo.endOffset &&
info.isAfterEndOfLine() == expectedInfo.isAfterEndOfLine() &&
(expectedInfo.type == WHATEVER || expectedInfo.type.equals(info.type)) &&
(Comparing.strEqual(ANY_TEXT, expectedInfo.getDescription()) || Comparing.strEqual(info.getDescription(),
expectedInfo.getDescription())) &&
(expectedInfo.forcedTextAttributes == null || Comparing.equal(expectedInfo.getTextAttributes(null, null),
info.getTextAttributes(null, null))) &&
(expectedInfo.forcedTextAttributesKey == null || expectedInfo.forcedTextAttributesKey.equals(info.forcedTextAttributesKey));
}
}