Program: 66970
Project: 66970
Buggy source:
public static DiffEngine buildRuntimeDeploymentXmlDiffEngine(){
  DiffEngine diffEngine=new DiffEngine();
  ReflectiveDifferentiator rd;
  rd=diffEngine.addReflectiveDifferentiator(Project.class);
  rd.addCollectionFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(DatasourceLogin.class);
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldsNamed("String_Node_Str");
  rd.setFieldDifferentiator("String_Node_Str",new ContainerDifferentiator(MapAdapter.instance(),new MapEntryDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      if (object1 == object2) {
        return new NullDiff(object1,object2,this);
      }
      if (((Map)object2).containsKey("String_Node_Str")) {
        if (((char[])((Map)object2).get("String_Node_Str")).length == 0 && !((Map)object1).containsKey("String_Node_Str")) {
          return new NullDiff(object1,object2,this);
        }
        if (((Map)object1).containsKey("String_Node_Str")) {
          char[] passwordArray1=(char[])((Map)object1).get("String_Node_Str");
          char[] passwordArray2=(char[])((Map)object1).get("String_Node_Str");
          if (passwordArray1 != null && passwordArray2 != null) {
            String password1=new String(passwordArray1);
            String password2=new String(passwordArray2);
            if (password1.equals(password2)) {
              return new NullDiff(object1,object2,this);
            }
          }
        }
      }
      return super.diff(object1,object2);
    }
  }
);
  diffEngine.setUserDifferentiator(DatasourcePlatform.class,new ReflectiveDifferentiator(DatasourcePlatform.class,diffEngine.getRecordingDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      if (object1 instanceof DatabasePlatform) {
        ((DatabasePlatform)object1).getDefaultSequence();
      }
      return super.diff(object1,object2);
    }
  }
);
  rd=(ReflectiveDifferentiator)diffEngine.getUserDifferentiator(DatasourcePlatform.class);
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.setFieldDifferentiator("String_Node_Str",new ContainerDifferentiator(MapAdapter.instance(),new MapEntryDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      if (object1 == object2) {
        return new NullDiff(object1,object2,this);
      }
      if (object2 == null && ((Map)object1).size() == 0) {
        return new NullDiff(object1,object2,this);
      }
      return super.diff(object1,object2);
    }
  }
);
  rd=diffEngine.addReflectiveDifferentiator(DefaultConnector.class);
  diffEngine.setUserDifferentiator(ClassDescriptor.class,new ReflectiveDifferentiator(ClassDescriptor.class,diffEngine.getRecordingDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      return new CompositeDiff(object1,object2,new Diff[]{super.diff(object1,object2),bonusDiff(object1,object2)},this);
    }
    private Diff bonusDiff(    Object object1,    Object object2){
      if (((ClassDescriptor)object1).getAmendmentClass() == null) {
        return new NullDiff(object1,object2,this);
      }
      String descriptor1Name=((ClassDescriptor)object1).getAmendmentClass().getName();
      String descriptor2Name=((ClassDescriptor)object2).getAmendmentClassName();
      return EqualityDifferentiator.instance().diff(descriptor1Name,descriptor2Name);
    }
  }
);
  rd=(ReflectiveDifferentiator)diffEngine.getUserDifferentiator(ClassDescriptor.class);
  rd.addCollectionFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.setKeyDifferentiator(new ReflectiveDifferentiator.KeyDifferentiator(){
    public Diff keyDiff(    Object object1,    Object object2){
      return EqualityDifferentiator.instance().diff(((ClassDescriptor)object1).getJavaClass().getName(),((ClassDescriptor)object2).getJavaClassName());
    }
  }
);
  rd=diffEngine.addReflectiveDifferentiator(RelationalDescriptor.class);
  rd=diffEngine.addReflectiveDifferentiator(XMLSchemaReference.class);
  rd=diffEngine.addReflectiveDifferentiator(QueryKey.class);
  rd.addKeyFieldNamed("String_Node_Str");
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(ObjectBuilder.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(AbstractCopyPolicy.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(DescriptorEventManager.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  diffEngine.setUserDifferentiator(DescriptorQueryManager.class,new ReflectiveDifferentiator(DescriptorQueryManager.class,diffEngine.getRecordingDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      ((DescriptorQueryManager)object1).getDoesExistCall();
      return super.diff(object1,object2);
    }
  }
);
  rd=(ReflectiveDifferentiator)diffEngine.getUserDifferentiator(DescriptorQueryManager.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  ContainerDifferentiator cd=rd.addMapFieldNamed("String_Node_Str");
  MapEntryDifferentiator med=(MapEntryDifferentiator)cd.getElementDifferentiator();
  med.setValueDifferentiator(ContainerDifferentiator.forCollections(rd.getDefaultFieldDifferentiator()));
  rd=diffEngine.addReflectiveDifferentiator(ConcurrentFixedCache.class);
  diffEngine.setUserDifferentiator(InheritancePolicy.class,new ReflectiveDifferentiator(InheritancePolicy.class,diffEngine.getRecordingDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      return new CompositeDiff(object1,object2,new Diff[]{super.diff(object1,object2),bonusDiff(object1,object2)},this);
    }
    private Diff bonusDiff(    Object object1,    Object object2){
      if (((InheritancePolicy)object1).getParentClass() == null) {
        return new NullDiff(object1,object2,this);
      }
      String parentClassName1=((InheritancePolicy)object1).getParentClass().getName();
      String parentClassName2=((InheritancePolicy)object2).getParentClassName();
      Map classIndicatorMapping=((InheritancePolicy)object1).getClassIndicatorMapping();
      Hashtable classIndicatorNameMapping1=new Hashtable();
      for (Iterator stream=classIndicatorMapping.keySet().iterator(); stream.hasNext(); ) {
        Object key=stream.next();
        classIndicatorNameMapping1.put(key,classIndicatorMapping.get(key));
      }
      Map classIndicatorNameMapping2=((InheritancePolicy)object2).getClassNameIndicatorMapping();
      return new CompositeDiff(object1,object2,new Diff[]{EqualityDifferentiator.instance().diff(parentClassName1,parentClassName2),ContainerDifferentiator.forMaps().diff(classIndicatorNameMapping1,classIndicatorNameMapping2)},this);
    }
  }
);
  rd=(ReflectiveDifferentiator)diffEngine.getUserDifferentiator(InheritancePolicy.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd.addReferenceFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(ClassExtractor.class);
  diffEngine.setUserDifferentiator(InstantiationPolicy.class,new ReflectiveDifferentiator(InstantiationPolicy.class,diffEngine.getRecordingDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      return new CompositeDiff(object1,object2,new Diff[]{super.diff(object1,object2),bonusDiff(object1,object2)},this);
    }
    private Diff bonusDiff(    Object object1,    Object object2){
      if (((InstantiationPolicy)object1).getFactoryClass() == null) {
        return new NullDiff(object1,object2,this);
      }
      String factoryClassName1=((InstantiationPolicy)object1).getFactoryClass().getName();
      String factoryClassName2=((InstantiationPolicy)object2).getFactoryClassName();
      return EqualityDifferentiator.instance().diff(factoryClassName1,factoryClassName2);
    }
  }
);
  rd=(ReflectiveDifferentiator)diffEngine.getUserDifferentiator(InstantiationPolicy.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(VersionLockingPolicy.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(FieldsLockingPolicy.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(DeferredChangeDetectionPolicy.class);
  rd=diffEngine.addReflectiveDifferentiator(ReturningPolicy.class);
  rd.ignoreFieldNamed("String_Node_Str");
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(CacheInvalidationPolicy.class);
  diffEngine.setUserDifferentiator(InterfacePolicy.class,new ReflectiveDifferentiator(InterfacePolicy.class,diffEngine.getRecordingDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      return new CompositeDiff(object1,object2,new Diff[]{super.diff(object1,object2),bonusDiff(object1,object2)},this);
    }
    private Diff bonusDiff(    Object object1,    Object object2){
      Vector parentInterfaces=((InterfacePolicy)object1).getParentInterfaces();
      Vector parentInterfaceNames1=new Vector();
      for (int i=0; i < parentInterfaces.size(); i++) {
        parentInterfaceNames1.add(((Class)parentInterfaces.get(i)).getName());
      }
      Vector parentInterfaceNames2=((InterfacePolicy)object1).getParentInterfaceNames();
      return EqualityDifferentiator.instance().diff(parentInterfaceNames1,parentInterfaceNames2);
    }
  }
);
  rd=(ReflectiveDifferentiator)diffEngine.getUserDifferentiator(InterfacePolicy.class);
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(DataReadQuery.class);
  rd=diffEngine.addReflectiveDifferentiator(QueryResultsCachePolicy.class);
  rd=diffEngine.addReflectiveDifferentiator(ReportItem.class);
  rd=diffEngine.addReflectiveDifferentiator(DatabaseQueryMechanism.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(Expression.class);
  rd=diffEngine.addReflectiveDifferentiator(BaseExpression.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(ObjectExpression.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(CompoundExpression.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd.addReferenceFieldNamed("String_Node_Str");
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(FunctionExpression.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd.ignoreFieldsNamed("String_Node_Str","String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(ConstantExpression.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd.setFieldDifferentiator("String_Node_Str",new ReflectiveDifferentiator(Object.class){
    public Diff diff(    Object object1,    Object object2){
      if (object1 == null && object2 == "String_Node_Str") {
        return new NullDiff(object1,object2,this);
      }
      return super.diff(object1,object2);
    }
  }
);
  rd=diffEngine.addReflectiveDifferentiator(LiteralExpression.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(ParameterExpression.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(QueryKeyExpression.class);
  rd.addKeyFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(DatasourceCall.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(ContainerPolicy.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(NullPolicy.class);
  diffEngine.setUserDifferentiator(DatabaseQuery.class,new ReflectiveDifferentiator(DatabaseQuery.class,diffEngine.getRecordingDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      return new CompositeDiff(object1,object2,new Diff[]{super.diff(object1,object2),bonusDiff(object1,object2)},this);
    }
    private Diff bonusDiff(    Object object1,    Object object2){
      Vector argumentTypes=((DatabaseQuery)object1).getArgumentTypes();
      Vector argumentTypeNames1=new Vector();
      for (int i=0; i < argumentTypes.size(); i++) {
        argumentTypeNames1.add(((Class)argumentTypes.get(i)).getName());
      }
      Vector argumentTypeNames2=((DatabaseQuery)object1).getArgumentTypeNames();
      return EqualityDifferentiator.instance().diff(argumentTypeNames1,argumentTypeNames2);
    }
  }
);
  rd=(ReflectiveDifferentiator)diffEngine.getUserDifferentiator(DatabaseQuery.class);
  rd.addKeyFieldNamed("String_Node_Str");
  rd.addReferenceFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.setFieldDifferentiator("String_Node_Str",new OrderedContainerDifferentiator(ListAdapter.instance()){
    public Diff diff(    Object object1,    Object object2){
      if (object1 == object2) {
        return new NullDiff(object1,object2,this);
      }
      if (object1 == null && ((List)object2).size() == 0) {
        return new NullDiff(object1,object2,this);
      }
      return super.diff(object1,object2);
    }
  }
);
  rd.setFieldDifferentiator("String_Node_Str",new OrderedContainerDifferentiator(ListAdapter.instance()){
    public Diff diff(    Object object1,    Object object2){
      if (object1 == object2) {
        return new NullDiff(object1,object2,this);
      }
      if (object1 == null && ((List)object2).size() == 0) {
        return new NullDiff(object1,object2,this);
      }
      return super.diff(object1,object2);
    }
  }
);
  rd=diffEngine.addReflectiveDifferentiator(ReadAllQuery.class);
  rd.ignoreFieldNamed("String_Node_Str");
  rd.setFieldDifferentiator("String_Node_Str",new OrderedContainerDifferentiator(ListAdapter.instance(),diffEngine.getRecordingDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      if (object1 == object2) {
        return new NullDiff(object1,object2,this);
      }
      if (object2 == null && ((List)object1).size() == 0) {
        return new NullDiff(object1,object2,this);
      }
      return super.diff(object1,object2);
    }
  }
);
  rd.setFieldDifferentiator("String_Node_Str",new OrderedContainerDifferentiator(ListAdapter.instance(),diffEngine.getUserDifferentiator(Expression.class)){
    public Diff diff(    Object object1,    Object object2){
      if (object1 == object2) {
        return new NullDiff(object1,object2,this);
      }
      if (((List)object1).size() == 0 && object2 == null) {
        return new NullDiff(object1,object2,this);
      }
      return super.diff(object1,object2);
    }
  }
);
  rd=(ReflectiveDifferentiator)diffEngine.setUserDifferentiator(ObjectLevelReadQuery.class,new ReflectiveDifferentiator(ObjectLevelReadQuery.class,diffEngine.getRecordingDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      if (object1 == null && object2 == null) {
        return new NullDiff(object1,object2,this);
      }
      if (object1 != null) {
        ((ObjectLevelReadQuery)object1).getJoinedAttributeManager();
      }
      if (object2 != null) {
        ((ObjectLevelReadQuery)object2).getJoinedAttributeManager();
      }
      return super.diff(object1,object2);
    }
  }
);
  rd=(ReflectiveDifferentiator)diffEngine.addReflectiveDifferentiator(ObjectBuildingQuery.class);
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd=(ReflectiveDifferentiator)diffEngine.addReflectiveDifferentiator(JoinedAttributeManager.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd.addReferenceFieldNamed("String_Node_Str");
  rd.addReferenceFieldNamed("String_Node_Str");
  rd.setFieldDifferentiator("String_Node_Str",new OrderedContainerDifferentiator(ListAdapter.instance(),diffEngine.getUserDifferentiator(Expression.class)){
    public Diff diff(    Object object1,    Object object2){
      if (object1 == object2) {
        return new NullDiff(object1,object2,this);
      }
      if (object1 != null && ((List)object1).size() == 0 && object2 == null) {
        return new NullDiff(object1,object2,this);
      }
      if (object2 != null && ((List)object2).size() == 0 && object1 == null) {
        return new NullDiff(object1,object2,this);
      }
      return super.diff(object1,object2);
    }
  }
);
  rd=(ReflectiveDifferentiator)diffEngine.getUserDifferentiator(ObjectLevelReadQuery.class);
  rd.ignoreFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(EISInteraction.class);
  rd.setFieldDifferentiator("String_Node_Str",new OrderedContainerDifferentiator(ListAdapter.instance()){
    public Diff diff(    Object object1,    Object object2){
      if (object1 == object2) {
        return new NullDiff(object1,object2,this);
      }
      if (object1 == null && ((List)object2).size() == 0) {
        return new NullDiff(object1,object2,this);
      }
      return super.diff(object1,object2);
    }
  }
);
  rd=diffEngine.addReflectiveDifferentiator(MappedInteraction.class);
  rd.setFieldDifferentiator("String_Node_Str",new OrderedContainerDifferentiator(ListAdapter.instance()){
    public Diff diff(    Object object1,    Object object2){
      if (object1 == object2) {
        return new NullDiff(object1,object2,this);
      }
      if (object1 == null && ((List)object2).size() == 0) {
        return new NullDiff(object1,object2,this);
      }
      return super.diff(object1,object2);
    }
  }
);
  rd=diffEngine.addReflectiveDifferentiator(InterfaceContainerPolicy.class);
  rd.setKeyDifferentiator(new ReflectiveDifferentiator.KeyDifferentiator(){
    public Diff keyDiff(    Object object1,    Object object2){
      return EqualityDifferentiator.instance().diff(((InterfaceContainerPolicy)object1).getContainerClassName(),((InterfaceContainerPolicy)object2).getContainerClassName());
    }
  }
);
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(InMemoryQueryIndirectionPolicy.class);
  rd=diffEngine.addReflectiveDifferentiator(ForUpdateClause.class);
  rd=diffEngine.addReflectiveDifferentiator(DatabaseMapping.class);
  rd.setKeyDifferentiator(new ReflectiveDifferentiator.SimpleMethodKeyDifferentiator("String_Node_Str"));
  rd.addReferenceFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd=(ReflectiveDifferentiator)diffEngine.setUserDifferentiator(AbstractTransformationMapping.class,new ReflectiveDifferentiator(AbstractTransformationMapping.class,diffEngine.getRecordingDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      if (((AbstractTransformationMapping)object1).getAttributeTransformerClass() == null && ((AbstractTransformationMapping)object2).getAttributeTransformerClassName() == null) {
        return new NullDiff(object1,object2,this);
      }
      String className1=((AbstractTransformationMapping)object1).getAttributeTransformerClass().getName();
      String className2=((AbstractTransformationMapping)object2).getAttributeTransformerClassName();
      return EqualityDifferentiator.instance().diff(className1,className2);
    }
  }
);
  rd.addCollectionFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  diffEngine.setUserDifferentiator(ForeignReferenceMapping.class,new ReflectiveDifferentiator(ForeignReferenceMapping.class,diffEngine.getRecordingDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      return new CompositeDiff(object1,object2,new Diff[]{super.diff(object1,object2),bonusDiff(object1,object2)},this);
    }
    private Diff bonusDiff(    Object object1,    Object object2){
      if (((ForeignReferenceMapping)object1).getReferenceClass() == null) {
        return new NullDiff(object1,object2,this);
      }
      String referenceClassName1=((ForeignReferenceMapping)object1).getReferenceClass().getName();
      String referenceClassName2=((ForeignReferenceMapping)object2).getReferenceClassName();
      return EqualityDifferentiator.instance().diff(referenceClassName1,referenceClassName2);
    }
  }
);
  rd=(ReflectiveDifferentiator)diffEngine.getUserDifferentiator(ForeignReferenceMapping.class);
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(CollectionMapping.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  diffEngine.setUserDifferentiator(ManyToManyMapping.class,new ReflectiveDifferentiator(ManyToManyMapping.class,diffEngine.getRecordingDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      DataModifyQuery query=((DataModifyQuery)ClassTools.getFieldValue(object1,"String_Node_Str"));
      query.getSelectionCriteria();
      query=((DataModifyQuery)ClassTools.getFieldValue(object1,"String_Node_Str"));
      query.getSelectionCriteria();
      query=((DataModifyQuery)ClassTools.invokeMethod(object1,"String_Node_Str"));
      query.getSelectionCriteria();
      return super.diff(object1,object2);
    }
  }
);
  diffEngine.setUserDifferentiator(VariableOneToOneMapping.class,new ReflectiveDifferentiator(VariableOneToOneMapping.class,diffEngine.getRecordingDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      return new CompositeDiff(object1,object2,new Diff[]{super.diff(object1,object2),bonusDiff(object1,object2)},this);
    }
    private Diff bonusDiff(    Object object1,    Object object2){
      Map typeIndicatorTranslation=((VariableOneToOneMapping)object1).getTypeIndicatorTranslation();
      Hashtable typeIndicatorNameTranslation1=new Hashtable();
      for (Iterator stream=typeIndicatorTranslation.keySet().iterator(); stream.hasNext(); ) {
        Object key=stream.next();
        if (key instanceof Class) {
          typeIndicatorNameTranslation1.put(((Class)key).getName(),typeIndicatorTranslation.get(key));
        }
      }
      Map typeIndicatorNameTranslation2=((VariableOneToOneMapping)object2).getTypeIndicatorNameTranslation();
      return EqualityDifferentiator.instance().diff(typeIndicatorNameTranslation1,typeIndicatorNameTranslation2);
    }
  }
);
  rd=(ReflectiveDifferentiator)diffEngine.getUserDifferentiator(VariableOneToOneMapping.class);
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.addReferenceMapFieldsNamed("String_Node_Str");
  diffEngine.setUserDifferentiator(AggregateMapping.class,new ReflectiveDifferentiator(AggregateMapping.class,diffEngine.getRecordingDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      return new CompositeDiff(object1,object2,new Diff[]{super.diff(object1,object2),bonusDiff(object1,object2)},this);
    }
    private Diff bonusDiff(    Object object1,    Object object2){
      if (((AggregateMapping)object1).getReferenceClass() == null) {
        return new NullDiff(object1,object2,this);
      }
      String referenceClassName1=((AggregateMapping)object1).getReferenceClass().getName();
      String referenceClassName2=((AggregateMapping)object2).getReferenceClassName();
      return EqualityDifferentiator.instance().diff(referenceClassName1,referenceClassName2);
    }
  }
);
  rd=(ReflectiveDifferentiator)diffEngine.getUserDifferentiator(AggregateMapping.class);
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(EISOneToOneMapping.class);
  rd.addReferenceMapFieldsNamed("String_Node_Str","String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(XMLDirectMapping.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(XMLCompositeObjectMapping.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(XMLCompositeCollectionMapping.class);
  rd=diffEngine.addReflectiveDifferentiator(XMLObjectReferenceMapping.class);
  rd.addReferenceMapFieldsNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(OneToOneMapping.class);
  rd.addReferenceMapFieldsNamed("String_Node_Str","String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(DatabaseField.class);
  rd.addKeyFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  Differentiator tableFieldDifferentiator=rd.getFieldDifferentiator("String_Node_Str");
  rd.setFieldDifferentiator("String_Node_Str",new DatabaseFieldTableFieldDifferentiator(tableFieldDifferentiator));
  rd=diffEngine.addReflectiveDifferentiator(DatabaseTable.class);
  rd.ignoreFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(IndirectionPolicy.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(AttributeAccessor.class);
  rd=diffEngine.addReflectiveDifferentiator(ObjectTypeConverter.class);
  rd.ignoreFieldNamed("String_Node_Str");
  diffEngine.setUserDifferentiator(TypeConversionConverter.class,new ReflectiveDifferentiator(TypeConversionConverter.class,diffEngine.getRecordingDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      return new CompositeDiff(object1,object2,new Diff[]{super.diff(object1,object2),bonusDiff(object1,object2)},this);
    }
    private Diff bonusDiff(    Object object1,    Object object2){
      if (((TypeConversionConverter)object1).getDataClass() == null) {
        return new NullDiff(object1,object2,this);
      }
      String dataClassName1=((TypeConversionConverter)object1).getDataClass().getName();
      String dataClassName2=((TypeConversionConverter)object2).getDataClassName();
      String objectClassName1=((TypeConversionConverter)object1).getObjectClass().getName();
      String objectClassName2=((TypeConversionConverter)object2).getObjectClassName();
      return new CompositeDiff(object1,object2,new Diff[]{EqualityDifferentiator.instance().diff(dataClassName1,dataClassName2),EqualityDifferentiator.instance().diff(objectClassName1,objectClassName2)},this);
    }
  }
);
  rd=(ReflectiveDifferentiator)diffEngine.getUserDifferentiator(TypeConversionConverter.class);
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(SerializedObjectConverter.class);
  rd.ignoreFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(MethodBasedAttributeTransformer.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(FieldTransformation.class);
  rd=diffEngine.addReflectiveDifferentiator(MethodBasedFieldTransformation.class);
  rd.addKeyFieldNamed("String_Node_Str");
  rd=(ReflectiveDifferentiator)diffEngine.setUserDifferentiator(TransformerBasedFieldTransformation.class,new ReflectiveDifferentiator(TransformerBasedFieldTransformation.class,diffEngine.getRecordingDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      if (((TransformerBasedFieldTransformation)object1).getTransformerClass() == null && ((TransformerBasedFieldTransformation)object2).getTransformerClassName() == null) {
        return new NullDiff(object1,object2,this);
      }
      String className1=((TransformerBasedFieldTransformation)object1).getTransformerClass().getName();
      String className2=((TransformerBasedFieldTransformation)object2).getTransformerClassName();
      return EqualityDifferentiator.instance().diff(className1,className2);
    }
  }
);
  rd.setKeyDifferentiator(new ReflectiveDifferentiator.SimpleMethodKeyDifferentiator("String_Node_Str"));
  rd=diffEngine.addReflectiveDifferentiator(EISConnectionSpec.class);
  rd=diffEngine.addReflectiveDifferentiator(NamespaceResolver.class);
  rd=diffEngine.addReflectiveDifferentiator(InitialContext.class);
  rd=diffEngine.addReflectiveDifferentiator(XMLComparer.class);
  return diffEngine;
}

Fixed version (ground truth):
public static DiffEngine buildRuntimeDeploymentXmlDiffEngine(){
  DiffEngine diffEngine=new DiffEngine();
  ReflectiveDifferentiator rd;
  rd=diffEngine.addReflectiveDifferentiator(Project.class);
  rd.addCollectionFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(DatasourceLogin.class);
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldsNamed("String_Node_Str");
  rd.setFieldDifferentiator("String_Node_Str",new ContainerDifferentiator(MapAdapter.instance(),new MapEntryDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      if (object1 == object2) {
        return new NullDiff(object1,object2,this);
      }
      if (((Map)object2).containsKey("String_Node_Str")) {
        if (((char[])((Map)object2).get("String_Node_Str")).length == 0 && !((Map)object1).containsKey("String_Node_Str")) {
          return new NullDiff(object1,object2,this);
        }
        if (((Map)object1).containsKey("String_Node_Str")) {
          char[] passwordArray1=(char[])((Map)object1).get("String_Node_Str");
          char[] passwordArray2=(char[])((Map)object1).get("String_Node_Str");
          if (passwordArray1 != null && passwordArray2 != null) {
            String password1=new String(passwordArray1);
            String password2=new String(passwordArray2);
            if (password1.equals(password2)) {
              return new NullDiff(object1,object2,this);
            }
          }
        }
      }
      return super.diff(object1,object2);
    }
  }
);
  diffEngine.setUserDifferentiator(DatasourcePlatform.class,new ReflectiveDifferentiator(DatasourcePlatform.class,diffEngine.getRecordingDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      if (object1 instanceof DatabasePlatform) {
        ((DatabasePlatform)object1).getDefaultSequence();
      }
      return super.diff(object1,object2);
    }
  }
);
  rd=(ReflectiveDifferentiator)diffEngine.getUserDifferentiator(DatasourcePlatform.class);
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.setFieldDifferentiator("String_Node_Str",new ContainerDifferentiator(MapAdapter.instance(),new MapEntryDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      if (object1 == object2) {
        return new NullDiff(object1,object2,this);
      }
      if (object2 == null && ((Map)object1).size() == 0) {
        return new NullDiff(object1,object2,this);
      }
      return super.diff(object1,object2);
    }
  }
);
  rd=diffEngine.addReflectiveDifferentiator(DefaultConnector.class);
  diffEngine.setUserDifferentiator(ClassDescriptor.class,new ReflectiveDifferentiator(ClassDescriptor.class,diffEngine.getRecordingDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      return new CompositeDiff(object1,object2,new Diff[]{super.diff(object1,object2),bonusDiff(object1,object2)},this);
    }
    private Diff bonusDiff(    Object object1,    Object object2){
      if (((ClassDescriptor)object1).getAmendmentClass() == null) {
        return new NullDiff(object1,object2,this);
      }
      String descriptor1Name=((ClassDescriptor)object1).getAmendmentClass().getName();
      String descriptor2Name=((ClassDescriptor)object2).getAmendmentClassName();
      return EqualityDifferentiator.instance().diff(descriptor1Name,descriptor2Name);
    }
  }
);
  rd=(ReflectiveDifferentiator)diffEngine.getUserDifferentiator(ClassDescriptor.class);
  rd.addCollectionFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.setKeyDifferentiator(new ReflectiveDifferentiator.KeyDifferentiator(){
    public Diff keyDiff(    Object object1,    Object object2){
      return EqualityDifferentiator.instance().diff(((ClassDescriptor)object1).getJavaClass().getName(),((ClassDescriptor)object2).getJavaClassName());
    }
  }
);
  rd=diffEngine.addReflectiveDifferentiator(RelationalDescriptor.class);
  rd=diffEngine.addReflectiveDifferentiator(XMLSchemaReference.class);
  rd=diffEngine.addReflectiveDifferentiator(QueryKey.class);
  rd.addKeyFieldNamed("String_Node_Str");
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(ObjectBuilder.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(AbstractCopyPolicy.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(DescriptorEventManager.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  diffEngine.setUserDifferentiator(DescriptorQueryManager.class,new ReflectiveDifferentiator(DescriptorQueryManager.class,diffEngine.getRecordingDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      ((DescriptorQueryManager)object1).getDoesExistCall();
      return super.diff(object1,object2);
    }
  }
);
  rd=(ReflectiveDifferentiator)diffEngine.getUserDifferentiator(DescriptorQueryManager.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  ContainerDifferentiator cd=rd.addMapFieldNamed("String_Node_Str");
  MapEntryDifferentiator med=(MapEntryDifferentiator)cd.getElementDifferentiator();
  med.setValueDifferentiator(ContainerDifferentiator.forCollections(rd.getDefaultFieldDifferentiator()));
  rd=diffEngine.addReflectiveDifferentiator(ConcurrentFixedCache.class);
  diffEngine.setUserDifferentiator(InheritancePolicy.class,new ReflectiveDifferentiator(InheritancePolicy.class,diffEngine.getRecordingDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      return new CompositeDiff(object1,object2,new Diff[]{super.diff(object1,object2),bonusDiff(object1,object2)},this);
    }
    private Diff bonusDiff(    Object object1,    Object object2){
      if (((InheritancePolicy)object1).getParentClass() == null) {
        return new NullDiff(object1,object2,this);
      }
      String parentClassName1=((InheritancePolicy)object1).getParentClass().getName();
      String parentClassName2=((InheritancePolicy)object2).getParentClassName();
      Map classIndicatorMapping=((InheritancePolicy)object1).getClassIndicatorMapping();
      Hashtable classIndicatorNameMapping1=new Hashtable();
      for (Iterator stream=classIndicatorMapping.keySet().iterator(); stream.hasNext(); ) {
        Object key=stream.next();
        classIndicatorNameMapping1.put(key,classIndicatorMapping.get(key));
      }
      Map classIndicatorNameMapping2=((InheritancePolicy)object2).getClassNameIndicatorMapping();
      return new CompositeDiff(object1,object2,new Diff[]{EqualityDifferentiator.instance().diff(parentClassName1,parentClassName2),ContainerDifferentiator.forMaps().diff(classIndicatorNameMapping1,classIndicatorNameMapping2)},this);
    }
  }
);
  rd=(ReflectiveDifferentiator)diffEngine.getUserDifferentiator(InheritancePolicy.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd.addReferenceFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(ClassExtractor.class);
  diffEngine.setUserDifferentiator(InstantiationPolicy.class,new ReflectiveDifferentiator(InstantiationPolicy.class,diffEngine.getRecordingDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      return new CompositeDiff(object1,object2,new Diff[]{super.diff(object1,object2),bonusDiff(object1,object2)},this);
    }
    private Diff bonusDiff(    Object object1,    Object object2){
      if (((InstantiationPolicy)object1).getFactoryClass() == null) {
        return new NullDiff(object1,object2,this);
      }
      String factoryClassName1=((InstantiationPolicy)object1).getFactoryClass().getName();
      String factoryClassName2=((InstantiationPolicy)object2).getFactoryClassName();
      return EqualityDifferentiator.instance().diff(factoryClassName1,factoryClassName2);
    }
  }
);
  rd=(ReflectiveDifferentiator)diffEngine.getUserDifferentiator(InstantiationPolicy.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(VersionLockingPolicy.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(FieldsLockingPolicy.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(DeferredChangeDetectionPolicy.class);
  rd=diffEngine.addReflectiveDifferentiator(ReturningPolicy.class);
  rd.ignoreFieldNamed("String_Node_Str");
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(CacheInvalidationPolicy.class);
  diffEngine.setUserDifferentiator(InterfacePolicy.class,new ReflectiveDifferentiator(InterfacePolicy.class,diffEngine.getRecordingDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      return new CompositeDiff(object1,object2,new Diff[]{super.diff(object1,object2),bonusDiff(object1,object2)},this);
    }
    private Diff bonusDiff(    Object object1,    Object object2){
      Vector parentInterfaces=((InterfacePolicy)object1).getParentInterfaces();
      Vector parentInterfaceNames1=new Vector();
      for (int i=0; i < parentInterfaces.size(); i++) {
        parentInterfaceNames1.add(((Class)parentInterfaces.get(i)).getName());
      }
      Vector parentInterfaceNames2=((InterfacePolicy)object1).getParentInterfaceNames();
      return EqualityDifferentiator.instance().diff(parentInterfaceNames1,parentInterfaceNames2);
    }
  }
);
  rd=(ReflectiveDifferentiator)diffEngine.getUserDifferentiator(InterfacePolicy.class);
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(DataReadQuery.class);
  rd=diffEngine.addReflectiveDifferentiator(QueryResultsCachePolicy.class);
  rd=diffEngine.addReflectiveDifferentiator(ReportItem.class);
  rd=diffEngine.addReflectiveDifferentiator(DatabaseQueryMechanism.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(Expression.class);
  rd=diffEngine.addReflectiveDifferentiator(BaseExpression.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(ObjectExpression.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(CompoundExpression.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd.addReferenceFieldNamed("String_Node_Str");
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(FunctionExpression.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd.ignoreFieldsNamed("String_Node_Str","String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(ConstantExpression.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd.setFieldDifferentiator("String_Node_Str",new ReflectiveDifferentiator(Object.class){
    public Diff diff(    Object object1,    Object object2){
      if (object1 == null && object2 == "String_Node_Str") {
        return new NullDiff(object1,object2,this);
      }
      return super.diff(object1,object2);
    }
  }
);
  rd=diffEngine.addReflectiveDifferentiator(LiteralExpression.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(ParameterExpression.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(QueryKeyExpression.class);
  rd.addKeyFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(DatasourceCall.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(ContainerPolicy.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(NullPolicy.class);
  diffEngine.setUserDifferentiator(DatabaseQuery.class,new ReflectiveDifferentiator(DatabaseQuery.class,diffEngine.getRecordingDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      return new CompositeDiff(object1,object2,new Diff[]{super.diff(object1,object2),bonusDiff(object1,object2)},this);
    }
    private Diff bonusDiff(    Object object1,    Object object2){
      List<Class> argumentTypes=((DatabaseQuery)object1).getArgumentTypes();
      Vector argumentTypeNames1=new Vector();
      for (int i=0; i < argumentTypes.size(); i++) {
        argumentTypeNames1.add(((Class)argumentTypes.get(i)).getName());
      }
      List<String> argumentTypeNames2=((DatabaseQuery)object1).getArgumentTypeNames();
      return EqualityDifferentiator.instance().diff(argumentTypeNames1,argumentTypeNames2);
    }
  }
);
  rd=(ReflectiveDifferentiator)diffEngine.getUserDifferentiator(DatabaseQuery.class);
  rd.addKeyFieldNamed("String_Node_Str");
  rd.addReferenceFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.setFieldDifferentiator("String_Node_Str",new OrderedContainerDifferentiator(ListAdapter.instance()){
    public Diff diff(    Object object1,    Object object2){
      if (object1 == object2) {
        return new NullDiff(object1,object2,this);
      }
      if (object1 == null && ((List)object2).size() == 0) {
        return new NullDiff(object1,object2,this);
      }
      return super.diff(object1,object2);
    }
  }
);
  rd.setFieldDifferentiator("String_Node_Str",new OrderedContainerDifferentiator(ListAdapter.instance()){
    public Diff diff(    Object object1,    Object object2){
      if (object1 == object2) {
        return new NullDiff(object1,object2,this);
      }
      if (object1 == null && ((List)object2).size() == 0) {
        return new NullDiff(object1,object2,this);
      }
      return super.diff(object1,object2);
    }
  }
);
  rd=diffEngine.addReflectiveDifferentiator(ReadAllQuery.class);
  rd.ignoreFieldNamed("String_Node_Str");
  rd.setFieldDifferentiator("String_Node_Str",new OrderedContainerDifferentiator(ListAdapter.instance(),diffEngine.getRecordingDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      if (object1 == object2) {
        return new NullDiff(object1,object2,this);
      }
      if (object2 == null && ((List)object1).size() == 0) {
        return new NullDiff(object1,object2,this);
      }
      return super.diff(object1,object2);
    }
  }
);
  rd.setFieldDifferentiator("String_Node_Str",new OrderedContainerDifferentiator(ListAdapter.instance(),diffEngine.getUserDifferentiator(Expression.class)){
    public Diff diff(    Object object1,    Object object2){
      if (object1 == object2) {
        return new NullDiff(object1,object2,this);
      }
      if (((List)object1).size() == 0 && object2 == null) {
        return new NullDiff(object1,object2,this);
      }
      return super.diff(object1,object2);
    }
  }
);
  rd=(ReflectiveDifferentiator)diffEngine.setUserDifferentiator(ObjectLevelReadQuery.class,new ReflectiveDifferentiator(ObjectLevelReadQuery.class,diffEngine.getRecordingDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      if (object1 == null && object2 == null) {
        return new NullDiff(object1,object2,this);
      }
      if (object1 != null) {
        ((ObjectLevelReadQuery)object1).getJoinedAttributeManager();
      }
      if (object2 != null) {
        ((ObjectLevelReadQuery)object2).getJoinedAttributeManager();
      }
      return super.diff(object1,object2);
    }
  }
);
  rd=(ReflectiveDifferentiator)diffEngine.addReflectiveDifferentiator(ObjectBuildingQuery.class);
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd=(ReflectiveDifferentiator)diffEngine.addReflectiveDifferentiator(JoinedAttributeManager.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd.addReferenceFieldNamed("String_Node_Str");
  rd.addReferenceFieldNamed("String_Node_Str");
  rd.setFieldDifferentiator("String_Node_Str",new OrderedContainerDifferentiator(ListAdapter.instance(),diffEngine.getUserDifferentiator(Expression.class)){
    public Diff diff(    Object object1,    Object object2){
      if (object1 == object2) {
        return new NullDiff(object1,object2,this);
      }
      if (object1 != null && ((List)object1).size() == 0 && object2 == null) {
        return new NullDiff(object1,object2,this);
      }
      if (object2 != null && ((List)object2).size() == 0 && object1 == null) {
        return new NullDiff(object1,object2,this);
      }
      return super.diff(object1,object2);
    }
  }
);
  rd=(ReflectiveDifferentiator)diffEngine.getUserDifferentiator(ObjectLevelReadQuery.class);
  rd.ignoreFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(EISInteraction.class);
  rd.setFieldDifferentiator("String_Node_Str",new OrderedContainerDifferentiator(ListAdapter.instance()){
    public Diff diff(    Object object1,    Object object2){
      if (object1 == object2) {
        return new NullDiff(object1,object2,this);
      }
      if (object1 == null && ((List)object2).size() == 0) {
        return new NullDiff(object1,object2,this);
      }
      return super.diff(object1,object2);
    }
  }
);
  rd=diffEngine.addReflectiveDifferentiator(MappedInteraction.class);
  rd.setFieldDifferentiator("String_Node_Str",new OrderedContainerDifferentiator(ListAdapter.instance()){
    public Diff diff(    Object object1,    Object object2){
      if (object1 == object2) {
        return new NullDiff(object1,object2,this);
      }
      if (object1 == null && ((List)object2).size() == 0) {
        return new NullDiff(object1,object2,this);
      }
      return super.diff(object1,object2);
    }
  }
);
  rd=diffEngine.addReflectiveDifferentiator(InterfaceContainerPolicy.class);
  rd.setKeyDifferentiator(new ReflectiveDifferentiator.KeyDifferentiator(){
    public Diff keyDiff(    Object object1,    Object object2){
      return EqualityDifferentiator.instance().diff(((InterfaceContainerPolicy)object1).getContainerClassName(),((InterfaceContainerPolicy)object2).getContainerClassName());
    }
  }
);
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(InMemoryQueryIndirectionPolicy.class);
  rd=diffEngine.addReflectiveDifferentiator(ForUpdateClause.class);
  rd=diffEngine.addReflectiveDifferentiator(DatabaseMapping.class);
  rd.setKeyDifferentiator(new ReflectiveDifferentiator.SimpleMethodKeyDifferentiator("String_Node_Str"));
  rd.addReferenceFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd=(ReflectiveDifferentiator)diffEngine.setUserDifferentiator(AbstractTransformationMapping.class,new ReflectiveDifferentiator(AbstractTransformationMapping.class,diffEngine.getRecordingDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      if (((AbstractTransformationMapping)object1).getAttributeTransformerClass() == null && ((AbstractTransformationMapping)object2).getAttributeTransformerClassName() == null) {
        return new NullDiff(object1,object2,this);
      }
      String className1=((AbstractTransformationMapping)object1).getAttributeTransformerClass().getName();
      String className2=((AbstractTransformationMapping)object2).getAttributeTransformerClassName();
      return EqualityDifferentiator.instance().diff(className1,className2);
    }
  }
);
  rd.addCollectionFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  diffEngine.setUserDifferentiator(ForeignReferenceMapping.class,new ReflectiveDifferentiator(ForeignReferenceMapping.class,diffEngine.getRecordingDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      return new CompositeDiff(object1,object2,new Diff[]{super.diff(object1,object2),bonusDiff(object1,object2)},this);
    }
    private Diff bonusDiff(    Object object1,    Object object2){
      if (((ForeignReferenceMapping)object1).getReferenceClass() == null) {
        return new NullDiff(object1,object2,this);
      }
      String referenceClassName1=((ForeignReferenceMapping)object1).getReferenceClass().getName();
      String referenceClassName2=((ForeignReferenceMapping)object2).getReferenceClassName();
      return EqualityDifferentiator.instance().diff(referenceClassName1,referenceClassName2);
    }
  }
);
  rd=(ReflectiveDifferentiator)diffEngine.getUserDifferentiator(ForeignReferenceMapping.class);
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(CollectionMapping.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  diffEngine.setUserDifferentiator(ManyToManyMapping.class,new ReflectiveDifferentiator(ManyToManyMapping.class,diffEngine.getRecordingDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      DataModifyQuery query=((DataModifyQuery)ClassTools.getFieldValue(object1,"String_Node_Str"));
      query.getSelectionCriteria();
      query=((DataModifyQuery)ClassTools.getFieldValue(object1,"String_Node_Str"));
      query.getSelectionCriteria();
      query=((DataModifyQuery)ClassTools.invokeMethod(object1,"String_Node_Str"));
      query.getSelectionCriteria();
      return super.diff(object1,object2);
    }
  }
);
  diffEngine.setUserDifferentiator(VariableOneToOneMapping.class,new ReflectiveDifferentiator(VariableOneToOneMapping.class,diffEngine.getRecordingDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      return new CompositeDiff(object1,object2,new Diff[]{super.diff(object1,object2),bonusDiff(object1,object2)},this);
    }
    private Diff bonusDiff(    Object object1,    Object object2){
      Map typeIndicatorTranslation=((VariableOneToOneMapping)object1).getTypeIndicatorTranslation();
      Hashtable typeIndicatorNameTranslation1=new Hashtable();
      for (Iterator stream=typeIndicatorTranslation.keySet().iterator(); stream.hasNext(); ) {
        Object key=stream.next();
        if (key instanceof Class) {
          typeIndicatorNameTranslation1.put(((Class)key).getName(),typeIndicatorTranslation.get(key));
        }
      }
      Map typeIndicatorNameTranslation2=((VariableOneToOneMapping)object2).getTypeIndicatorNameTranslation();
      return EqualityDifferentiator.instance().diff(typeIndicatorNameTranslation1,typeIndicatorNameTranslation2);
    }
  }
);
  rd=(ReflectiveDifferentiator)diffEngine.getUserDifferentiator(VariableOneToOneMapping.class);
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.addReferenceMapFieldsNamed("String_Node_Str");
  diffEngine.setUserDifferentiator(AggregateMapping.class,new ReflectiveDifferentiator(AggregateMapping.class,diffEngine.getRecordingDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      return new CompositeDiff(object1,object2,new Diff[]{super.diff(object1,object2),bonusDiff(object1,object2)},this);
    }
    private Diff bonusDiff(    Object object1,    Object object2){
      if (((AggregateMapping)object1).getReferenceClass() == null) {
        return new NullDiff(object1,object2,this);
      }
      String referenceClassName1=((AggregateMapping)object1).getReferenceClass().getName();
      String referenceClassName2=((AggregateMapping)object2).getReferenceClassName();
      return EqualityDifferentiator.instance().diff(referenceClassName1,referenceClassName2);
    }
  }
);
  rd=(ReflectiveDifferentiator)diffEngine.getUserDifferentiator(AggregateMapping.class);
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(EISOneToOneMapping.class);
  rd.addReferenceMapFieldsNamed("String_Node_Str","String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(XMLDirectMapping.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(XMLCompositeObjectMapping.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(XMLCompositeCollectionMapping.class);
  rd=diffEngine.addReflectiveDifferentiator(XMLObjectReferenceMapping.class);
  rd.addReferenceMapFieldsNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(OneToOneMapping.class);
  rd.addReferenceMapFieldsNamed("String_Node_Str","String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(DatabaseField.class);
  rd.addKeyFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  Differentiator tableFieldDifferentiator=rd.getFieldDifferentiator("String_Node_Str");
  rd.setFieldDifferentiator("String_Node_Str",new DatabaseFieldTableFieldDifferentiator(tableFieldDifferentiator));
  rd=diffEngine.addReflectiveDifferentiator(DatabaseTable.class);
  rd.ignoreFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(IndirectionPolicy.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(AttributeAccessor.class);
  rd=diffEngine.addReflectiveDifferentiator(ObjectTypeConverter.class);
  rd.ignoreFieldNamed("String_Node_Str");
  diffEngine.setUserDifferentiator(TypeConversionConverter.class,new ReflectiveDifferentiator(TypeConversionConverter.class,diffEngine.getRecordingDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      return new CompositeDiff(object1,object2,new Diff[]{super.diff(object1,object2),bonusDiff(object1,object2)},this);
    }
    private Diff bonusDiff(    Object object1,    Object object2){
      if (((TypeConversionConverter)object1).getDataClass() == null) {
        return new NullDiff(object1,object2,this);
      }
      String dataClassName1=((TypeConversionConverter)object1).getDataClass().getName();
      String dataClassName2=((TypeConversionConverter)object2).getDataClassName();
      String objectClassName1=((TypeConversionConverter)object1).getObjectClass().getName();
      String objectClassName2=((TypeConversionConverter)object2).getObjectClassName();
      return new CompositeDiff(object1,object2,new Diff[]{EqualityDifferentiator.instance().diff(dataClassName1,dataClassName2),EqualityDifferentiator.instance().diff(objectClassName1,objectClassName2)},this);
    }
  }
);
  rd=(ReflectiveDifferentiator)diffEngine.getUserDifferentiator(TypeConversionConverter.class);
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd.ignoreFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(SerializedObjectConverter.class);
  rd.ignoreFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(MethodBasedAttributeTransformer.class);
  rd.addReferenceFieldNamed("String_Node_Str");
  rd=diffEngine.addReflectiveDifferentiator(FieldTransformation.class);
  rd=diffEngine.addReflectiveDifferentiator(MethodBasedFieldTransformation.class);
  rd.addKeyFieldNamed("String_Node_Str");
  rd=(ReflectiveDifferentiator)diffEngine.setUserDifferentiator(TransformerBasedFieldTransformation.class,new ReflectiveDifferentiator(TransformerBasedFieldTransformation.class,diffEngine.getRecordingDifferentiator()){
    public Diff diff(    Object object1,    Object object2){
      if (((TransformerBasedFieldTransformation)object1).getTransformerClass() == null && ((TransformerBasedFieldTransformation)object2).getTransformerClassName() == null) {
        return new NullDiff(object1,object2,this);
      }
      String className1=((TransformerBasedFieldTransformation)object1).getTransformerClass().getName();
      String className2=((TransformerBasedFieldTransformation)object2).getTransformerClassName();
      return EqualityDifferentiator.instance().diff(className1,className2);
    }
  }
);
  rd.setKeyDifferentiator(new ReflectiveDifferentiator.SimpleMethodKeyDifferentiator("String_Node_Str"));
  rd=diffEngine.addReflectiveDifferentiator(EISConnectionSpec.class);
  rd=diffEngine.addReflectiveDifferentiator(NamespaceResolver.class);
  rd=diffEngine.addReflectiveDifferentiator(InitialContext.class);
  rd=diffEngine.addReflectiveDifferentiator(XMLComparer.class);
  return diffEngine;
}