1 files changed, 0 insertions, 143 deletions
diff --git a/aspectj-attic/testing-src/org/aspectj/testing/compare/CompareUtil.java b/aspectj-attic/testing-src/org/aspectj/testing/compare/CompareUtil.java
deleted file mode 100644
index 8358a177d..000000000
--- a/aspectj-attic/testing-src/org/aspectj/testing/compare/CompareUtil.java
+++ /dev/null
@@ -1,143 +0,0 @@
-/* *******************************************************************
- * Copyright (c) 1999-2001 Xerox Corporation, 
- *               2002 Palo Alto Research Center, Incorporated (PARC).
- * All rights reserved. 
- * This program and the accompanying materials are made available 
- * under the terms of the Common Public License v1.0 
- * which accompanies this distribution and is available at 
- * http://www.eclipse.org/legal/cpl-v10.html 
- *  
- * Contributors: 
- *     Xerox/PARC     initial implementation 
- * ******************************************************************/
-
-package org.aspectj.testing.compare;
-
-import java.util.Iterator;
-import java.util.Collection;
-import java.util.List;
-
-/** Minor methods for short-circuiting comparisons */
-public class CompareUtil {    
-    /**
-     * Callers may abort equality checks with false
-     * if this passes its misc short-circuit semantics.
-     * A false result does not mean the arguments
-     * are equal, but a true result does mean they are not equal. 
-     * <pre>if (notSame(foo,bar,true)) then return false;</pre>
-     * @param lhs the Object on the left-hand-side to compare
-     * @param rhs the Object on the right-hand-side to compare
-     * @param considerType if true, then also return true if the 
-     *           right-hand-side cannot be assigned to the left-hand-side
-     * @return true if lhs and rhs are not the same per considerType.
-     */
-    public static boolean notSame(Object lhs, Object rhs, boolean considerType) {
-        if (null == lhs) {
-            return (!(null == rhs));
-        } else if (null == rhs) {
-            return true;
-        } else if (lhs== rhs) {
-            return false;  // known to be same
-        } else if (considerType) {
-            Class lhClass = lhs.getClass();
-            Class rhClass = rhs.getClass();
-            if (!lhClass.isAssignableFrom(rhClass)) {
-                return true;
-            }
-        }
-        return false; // unknown whether equal or not
-    }    
-
-    /**
-     * Return null/equal comparison:
-     * <li>null considered to be lesser</li>
-     * <li>reference or Object.equals() considered to be 0</li>
-     * <li>return Integer.MAX_VALUE for all other cases</li>
-     * <table>
-     * <tr><td>result</td><td>input</td></tr>
-     * <tr><td>-1</td><td>null &lt; rhs</td></tr>
-     * <tr><td>1</td><td>lhs &gt; null</td></tr>
-     * <tr><td>0</td><td>null == null</td></tr>
-     * <tr><td>0</td><td>lhs == rhs</td></tr>
-     * <tr><td>0</td><td>lhs.equals(rhs)</td></tr>
-     * <tr><td>Integer.MAX_VALUE</td><td>{all other cases}</td></tr>
-     * </table>
-     * @see Comparator
-     * @return Integer.MAX_VALUE if uncertain, value otherwise
-     */
-    public static int compare(Object lhs, Object rhs) {
-        if (null == lhs) {
-            return (null == rhs ? 0 : -1);
-        } else if (null == rhs) {
-            return 1;
-        } else if (lhs == rhs) {
-            return 0;  // known to be same
-        } else {
-            return Integer.MAX_VALUE;
-        }
-    }
-
-    /**
-     * Return boolean comparison where true > false.
-     * (Comparable not defined for Boolean)
-     * @see Comparator
-     */
-    public static int compare(boolean lhs, boolean rhs) {
-        return (lhs == rhs ? 0 : (lhs ? 1 : -1));
-    }
-
-    /**
-     * Return String comparison based on {@link compare(Object,Object)}
-     * and {@link String.compareTo(String)}.
-     * @see Comparator
-     */
-    public static int compare(String lhs, String rhs) {
-        int result = compare((Object) lhs, (Object) rhs);
-        if (Integer.MAX_VALUE == result) {
-            result = lhs.compareTo(rhs);
-        }
-        return result;
-    }
-
-    /**
-     * Compare two Collections by reference to a standard List.
-     * The first Collection to not contain a standard element 
-     * when the other does loses. Order is ignored.
-     * The left-hand-side acts as the standard if the standard is null.
-     * @param lhs the List from the left-hand-side
-     * @param rhs the Collection from the right-hand-side
-     * @param standard the List to act as the standard (if null, use lhs)
-     * @param return -1 if lhs is null and rhs is not, 1 if reverse;
-     *        0 if both have all elements in standard,
-     *        1 if lhs has a standard element rhs does not, -1 if reverse
-     *        (testing in standard order)
-     */
-    public static int compare(List lhs, Collection rhs, List standard) {
-        int result = compare(lhs, rhs);
-        if (result == Integer.MAX_VALUE) {
-            if (null == standard) {
-                result = compare(lhs, rhs, lhs); // use lhs as standard
-            } else {
-                boolean leftHasThem = lhs.containsAll(standard);
-                boolean rightHasThem = rhs.containsAll(standard);
-                if (leftHasThem != rightHasThem) {
-                    result = (leftHasThem ? 1 : -1);
-                } else if (leftHasThem) {
-                    result = 0; // they both have them
-                } else {        // first to not have an element loses
-                    Iterator standardIterator = standard.iterator();
-                    while (standardIterator.hasNext()) {
-                        Object standardObject = standardIterator.next();
-                        boolean leftHasIt = lhs.contains(standardObject);
-                        boolean rightHasIt = rhs.contains(standardObject);
-                        if (leftHasIt != rightHasIt) {
-                            result = (leftHasIt ? 1 : -1);
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-        return result;
-    }
-} // class Util