From: wisberg Date: Wed, 14 May 2003 05:05:08 +0000 (+0000) Subject: - revamped message comparators, X-Git-Tag: V1_1_0~124 X-Git-Url: https://source.dussan.org/?a=commitdiff_plain;h=3527ce95d12822f9b6374a808e668476f22e713f;p=aspectj.git - revamped message comparators, mostly adding medium-level and consolidating common code --- diff --git a/testing/src/org/aspectj/testing/util/BridgeUtil.java b/testing/src/org/aspectj/testing/util/BridgeUtil.java index 963a7f551..325656e84 100644 --- a/testing/src/org/aspectj/testing/util/BridgeUtil.java +++ b/testing/src/org/aspectj/testing/util/BridgeUtil.java @@ -109,97 +109,176 @@ public class BridgeUtil { } - public static class Comparators { + public static class Comparators { + /** + * Compare based solely on null-inequality: + * -1 if one is not null and two is null, + * 1 if one is null and two is not null, + * 0 otherwise. + */ + static int compareNull(Object one, Object two) { + return (null == one + ? (null == two ? 0 : 1) + : (null == two ? -1 : 0)); + } + + /** + * Soft comparison of String returns 0 if either is empty + * or a substring of the other, and the case-insensitive + * ordering otherwise. + * @param lhs_s + * @param rhs_s + * @return + */ + static int compareStringsSoftly(String lhs_s, String rhs_s) { + if (LangUtil.isEmpty(lhs_s) + || LangUtil.isEmpty(rhs_s)) { + return 0; + } + if ((-1 != lhs_s.indexOf(rhs_s)) + || (-1 != rhs_s.indexOf(lhs_s))) { + return 0; + } + return String.CASE_INSENSITIVE_ORDER.compare(lhs_s, rhs_s); + } + /** - * This is a weak ordering - * so use only for sorts, not to maintain maps. - * It returns 0 if one file path is a suffix of the other + * This returns 0 if one file path is a suffix of the other * or a case-insensitive string comparison otherwise. + * WARNING: it returns 0 if either file is + * ISourceLocation.NO_FILE to permit tests to + * not specify file paths. + * + * Use only for sorts, not to maintain maps. */ public static final Comparator WEAK_File = new Comparator() { public int compare(Object o1, Object o2) { + if ((o1 == o2) + || (o1 == ISourceLocation.NO_FILE) + || (o2 == ISourceLocation.NO_FILE) ) { + return 0; + } + int result = compareNull(o1, o2); + if (0 != result) { + return result; + } File one = (File) o1; File two = (File) o2; - if (null == one) { - return (null == two ? 0 : 1); - } else if (null == two) { - return -1; - } else if (one == two) { + String s1 = one.getPath(); + String s2 = two.getPath(); + // check if normalize needed + if (s1.endsWith(s2) || s2.endsWith(s1)) { return 0; - } else { - String s1 = FileUtil.weakNormalize(one.getPath()); - String s2 = FileUtil.weakNormalize(two.getPath()); - if (s1.endsWith(s2) || s2.endsWith(s1)) { - return 0; - } else { - return String.CASE_INSENSITIVE_ORDER.compare(s1, s2); - } } - }}; + s1 = FileUtil.weakNormalize(s1); + s2 = FileUtil.weakNormalize(s2); + if (s1.endsWith(s2) || s2.endsWith(s1)) { + return 0; + } + return String.CASE_INSENSITIVE_ORDER.compare(s1, s2); + + } + }; /** - * Ordering ignores filename, - * so use only for sorts, not to maintain maps + * Ordering only uses line number. + * Use only for sorts, not to maintain maps. */ public static final Comparator WEAK_ISourceLocation = new Comparator() { public int compare(Object o1, Object o2) { + if (o1 == o2) { + return 0; + } + int result = compareNull(o1, o2); + if (0 != result) { + return result; + } ISourceLocation one = (ISourceLocation) o1; ISourceLocation two = (ISourceLocation) o2; - if (null == one) { - return (null == two ? 0 : 1); - } else if (null == two) { - return -1; - } else if (one == two) { + int i1 = one.getLine(); + int i2 = two.getLine(); + return i1 - i2; + } + }; + + /** + * Like WEAK_ISourceLocation, except it also + * uses WEAK_FILE on the sourceFile. + * Use only for sorts, not to maintain maps. + */ + public static final Comparator MEDIUM_ISourceLocation = new Comparator() { + public int compare(Object o1, Object o2) { + int result = WEAK_ISourceLocation.compare(o1, o2); + if (0 != result) { + return result; + } + ISourceLocation one = (ISourceLocation) o1; + ISourceLocation two = (ISourceLocation) o2; + result = compareNull(one, two); + if (0 != result) { // one but not other is null + return result; + } + if (null == one) { // both null return 0; - } else { // XXX start with File to make strong - int i1 = one.getLine(); - int i2 = two.getLine(); - return i1 - i2; -// // defer subcomparisons until messages complete -// if (i1 != i2) { -// return i1 - i2; -// } else { -// i1 = one.getColumn(); -// i2 = two.getColumn(); -// if (i1 != i2) { -// return i1 - i2; -// } else { -// i1 = one.getEndLine(); -// i2 = two.getEndLine(); -// return i1 - i2; -// } -// } } - }}; - + // neither null + return WEAK_File.compare(one.getSourceFile(), two.getSourceFile()); + } + }; + /** - * Ordering ignores filename and message + * Ordering uses kind and weak source location, + * and ignores message * so use only for sorts, not to maintain maps */ public static final Comparator WEAK_IMessage = new Comparator() { public int compare(Object o1, Object o2) { + if (o1 == o2) { + return 0; + } + int result = compareNull(o1, o2); + if (0 != result) { + return result; + } IMessage one = (IMessage) o1; IMessage two = (IMessage) o2; - if (null == one) { - return (null == two ? 0 : 1); - } else if (null == two) { - return -1; - } else if (one == two) { - return 0; - } else { - IMessage.Kind kind1 = one.getKind(); - IMessage.Kind kind2= two.getKind(); - if (kind1 != kind2) { - return IMessage.Kind.COMPARATOR.compare(kind1, kind2); - } else { - ISourceLocation sl1 = one.getISourceLocation(); - ISourceLocation sl2 = two.getISourceLocation(); - return WEAK_ISourceLocation.compare(sl1, sl2); - } + IMessage.Kind kind1 = one.getKind(); + IMessage.Kind kind2= two.getKind(); + result = IMessage.Kind.COMPARATOR.compare(kind1, kind2); + if (0 != result) { + return result; } - }}; - - } + ISourceLocation sl1 = one.getISourceLocation(); + ISourceLocation sl2 = two.getISourceLocation(); + return WEAK_ISourceLocation.compare(sl1, sl2); + } + }; + /** + * Ordering uses line and weak filename and message + * (message matches if either is a substring of the other, + * or if either is empty, i.e., none specified). + * so use only for sorts, not to maintain maps + */ + public static final Comparator MEDIUM_IMessage = new Comparator() { + public int compare(Object o1, Object o2) { + int result = WEAK_IMessage.compare(o1, o2); + if (0 != result) { + return result; + } + IMessage rhs_m= (IMessage) o1; + IMessage lhs_m = (IMessage) o2; + ISourceLocation rhs_sl = rhs_m.getISourceLocation(); + ISourceLocation lhs_sl = lhs_m.getISourceLocation(); + result = MEDIUM_ISourceLocation.compare(lhs_sl, rhs_sl); + if (0 != result) { + return result; + } + String lhs_s =lhs_m.getMessage(); + String rhs_s = rhs_m.getMessage(); + return compareStringsSoftly(lhs_s, rhs_s); + } + }; +} public static SourceLocation makeSourceLocation(String input) { // XXX only for testing, not production return makeSourceLocation(input, (File) null); }