/**
* JComponents are really equal if their names are the same (or this is better than the
* Object.equals()/hashCode() that is used by default for JComponents). Note that <code>
* ReasonNotEquals</code> can be used to determine the reason for a failure
*
* @param arr1 first array of components
* @param arr2 second array of components
* @return true if the arrays are equal
*/
public static boolean equalsComponentArrays(JComponent[] arr1, JComponent[] arr2) {
ReasonNotEquals.addClassVisiting("pUtils.equalsComponentArrays()");
boolean result = true;
if (arr1 != arr2) {
// if(arr1.getClass() == arr2.getClass() &&
// JComponent.class.isAssignableFrom( arr1.getClass()))
// {
if (arr1.length == arr2.length) {
int size = arr1.length;
for (int i = 0; i < size; i++) {
String e1 = arr1[i].getName();
String e2 = arr2[i].getName();
if (e1 == null ? e2 == null : e1.equals(e2)) { // keep on being true
} else {
ReasonNotEquals.addReason("component names not equal: " + e1 + ", " + e2);
result = false;
break;
}
}
} else {
ReasonNotEquals.addReason("component arrays different sizes");
result = false;
}
// }
// else
// {
// result = false;
// }
}
return result;
}
/**
* Method to use when we are needing to see if two sets of components are equal when we are
* considering them as JavaBeans. If all the properties of each component are equal, then the two
* sets are equal. 'all the properties' is determined by recursing down to the child components
*
* @param components first array of components
* @param components2 second array of components
* @param widgetClassifier Provides this method with a definition of a component
*/
public static boolean equalsByProperties(
JComponent[] components, JComponent[] components2, WidgetClassifierI widgetClassifier) {
ReasonNotEquals.addClassVisiting("pUtils.equalsByProperties([])");
boolean result = true;
if (components.length != components2.length) {
ReasonNotEquals.addReason(
"got lists of components of different sizes: "
+ components.length
+ " and "
+ components2.length);
result = false;
} else {
for (int i = 0; i < components.length; i++) {
JComponent comp1 = components[i];
JComponent comp2 = components2[i];
// not work due to diff classloaders having been used
// if(comp1.getClass() != comp2.getClass())
if (!comp1.getClass().getName().equals(comp2.getClass().getName())) {
ReasonNotEquals.addReason(
"two components were not of the same class: "
+ comp1.getClass()
+ " and "
+ comp2.getClass());
result = false;
break;
} else {
result = equalsByProperties(comp1, comp2, widgetClassifier);
if (!result) {
ReasonNotEquals.addReason(
"equalsByProperties() failed for 2 classes of type: " + comp1.getClass().getName());
break;
}
}
}
}
return result;
}
public static boolean equalsByProperties(
JComponent component1, JComponent component2, WidgetClassifierI widgetClassifier) {
ReasonNotEquals.addClassVisiting("pUtils.equalsByProperties()");
boolean result = true;
List oneControls = getAllControls(component1);
oneControls.add(0, component1);
List twoControls = getAllControls(component2);
twoControls.add(0, component2);
if (oneControls.size() != twoControls.size()) {
ReasonNotEquals.addReason(
"got lists of controls of different sizes: "
+ oneControls.size()
+ " and "
+ twoControls.size());
Print.prList(oneControls, "oneControls");
Print.prList(twoControls, "twoControls");
result = false;
} else {
for (int i = 0; i < oneControls.size(); i++) {
Container comp1 = (Container) oneControls.get(i);
// Err.pr( "Observing a " + comp1.getClass());
Container comp2 = (Container) twoControls.get(i);
if (comp1.getClass() != comp2.getClass()) {
ReasonNotEquals.addReason(
"first component is of type "
+ comp1.getClass()
+ " while second is of type "
+ comp2.getClass());
result = false;
break;
} else if (!Utils.equals(comp1.getName(), comp2.getName())) {
ReasonNotEquals.addReason(
"first component has name "
+ comp1.getName()
+ " while second has name "
+ comp2.getName());
result = false;
break;
} else if (widgetClassifier != null
&& !widgetClassifier.isAWidget(
comp1.getClass())) { // If a comp1/comp2 is not a widget then end up here and we
// won't examine
// its properties
// Err.pr( comp1.getClass() + " is not a widget: " + widgetClassifier.getReason());
} else {
List propertyNamesOne = new ArrayList();
List propertyNamesTwo = new ArrayList();
List propertyValuesOne = new ArrayList();
List propertyValuesTwo = new ArrayList();
loadPropertyNamesValues(comp1.getClass(), comp1, propertyNamesOne, propertyValuesOne);
loadPropertyNamesValues(comp2.getClass(), comp2, propertyNamesTwo, propertyValuesTwo);
if (propertyNamesOne.size() != propertyValuesOne.size()) {
Err.error("expect names and properties to be same size for " + comp1.getClass());
} else if (propertyNamesTwo.size() != propertyValuesTwo.size()) {
Err.error("expect names and properties to be same size for " + comp2.getClass());
} else if (propertyNamesOne.size() != propertyNamesTwo.size()) {
ReasonNotEquals.addReason(
"there should be an equal number of properties in "
+ comp1.getClass()
+ " and "
+ comp2.getClass());
result = false;
break;
} else {
// Err.pr( "Will be examining properties from a " + comp1.getClass() + " against " +
// comp2.getClass());
for (int j = 0; j < propertyNamesOne.size(); j++) {
String onePropName = (String) propertyNamesOne.get(j);
String twoPropName = (String) propertyNamesTwo.get(j);
if (!onePropName.equals(twoPropName)) {
// If they are of thge same type, how could they possibly have
// different property names, thus make this an error
String txt =
"expect property names to be equal, got " + onePropName + " and " + twoPropName;
// ReasonNotEquals.addReason( txt);
Err.error(txt);
result = false;
break;
} else {
Object onePropValue = propertyValuesOne.get(j);
Object twoPropValue = propertyValuesTwo.get(j);
boolean debug = false;
/*
if(onePropName.equals( "text"))
{
Err.debug();
debug = true;
}
*/
if (onePropValue.getClass() != twoPropValue.getClass()) {
Err.error(
"Property values to be examining should be of the same type, got "
+ onePropValue.getClass().getName()
+ " and "
+ twoPropValue.getClass().getName());
result = false;
break;
} else if (!Utils.isSimple(onePropValue.getClass())) {
// We only want to do value comparisons for simple types
// Err.pr( "Not simple: <" + onePropValue + ">");
if (debug) {
Err.error("Only supposed to be debugging on a simple property value");
}
} else {
if (debug) {
Err.pr(
"Doing cf between <"
+ onePropValue
+ "> and <"
+ twoPropValue
+ "> for "
+ onePropName
+ " in a "
+ comp1.getClass());
debug = false;
}
if (!onePropValue.equals(twoPropValue)) {
ReasonNotEquals.addReason(
"expect property values to be equal, got <"
+ onePropValue
+ "> and <"
+ twoPropValue
+ ">");
result = false;
break;
} else { // Err.pr( "\tconcordance, prop name " + onePropName + ", prop value " +
// onePropValue);
}
}
}
}
if (result == false) {
break; // so break out of outer loop too
}
}
}
}
}
return result;
}
