Asserted property statement processing was flawed.

[simantics/interop.git] / org.simantics.interop / src / org / simantics / interop / test / GraphComparator.java

diff --git a/org.simantics.interop/src/org/simantics/interop/test/GraphComparator.java b/org.simantics.interop/src/org/simantics/interop/test/GraphComparator.java
index 9f14ecdebe6fdc75dd76f377fc472e0818731cfa..8ce5a9d66c0b4248a8c3b496bc8ce88e8a16cff3 100644 (file)
--- a/org.simantics.interop/src/org/simantics/interop/test/GraphComparator.java
+++ b/org.simantics.interop/src/org/simantics/interop/test/GraphComparator.java
@@ -790,6 +790,14 @@ public class GraphComparator {
                return new GraphChanges(r1,r2,changes1,changes2,modifications,comparableResources);
        }
        
+       public List<Statement> getChanges1() {
+               return changes1;
+       }
+       
+       public List<Statement> getChanges2() {
+               return changes2;
+       }
+       
        private void addComparable(Statement left, Statement right) throws DatabaseException {
                addComparable(left.getObject(), right.getObject());
                comparableStatements.map(left, right);
@@ -826,7 +834,7 @@ public class GraphComparator {
                                out.add(s);
                        else {
                                boolean has = false;
-                               if (i > 1 && in.get(i-1).getPredicate().equals(s.getPredicate()))
+                               if (i > 0 && in.get(i-1).getPredicate().equals(s.getPredicate()))
                                        has = true;
                                else if (i < in.size()-1 && in.get(i+1).getPredicate().equals(s.getPredicate()))
                                        has = true;
@@ -834,11 +842,6 @@ public class GraphComparator {
                                        out.add(s);
                        }
                        
-               }
-               for (Statement s : in) {
-                       if (!s.isAsserted(r))
-                               out.add(s);
-                       
                }
                return out;
        }
@@ -896,8 +899,8 @@ public class GraphComparator {
                }
        }
        
-       private void addModification(Resource sub1, Statement s1, Resource sub2, Statement s2) {
-               Modification mod = new Modification(sub1, sub2, s1, s2);
+       private void addModification(Resource left, Statement leftstm, Resource right, Statement rightstm) {
+               Modification mod = new Modification(left, right, leftstm, rightstm);
                if (!modificationsSet.contains(mod)) {
                        modificationsSet.add(mod);
                        modifications.add(mod);
@@ -1252,25 +1255,41 @@ public class GraphComparator {
                                case 0:{
                                        boolean b1 = g.hasValue(s1.getObject());
                                        boolean b2 = g.hasValue(s2.getObject());
+                                       boolean a1 = s1.isAsserted(r1);
+                                       boolean a2 = s2.isAsserted(r2);
                                        if (b1 == b2) {
                                                if (b1) {
-//                                                     Object v1 = g.getValue(s1.getObject());
-//                                                     Object v2 = g.getValue(s2.getObject());
-//                                                     boolean eq = compareValue(v1, v2);
+                                                       // Literals
                                                        boolean eq = compareValue(g,b,s1.getObject(), s2.getObject());
                                                        if (!eq) {
                                                                addModification(r1,s1,r2,s2);
-                                                               if (!s1.isAsserted(r1) && !s2.isAsserted(r2))
+                                                               if (!a1 && !a2)
                                                                        addComparable(s1, s2);
                                                        }
                                                } else {
-                                                       if (!s1.getObject().equals(s1.getSubject()) && !s2.getObject().equals(s2.getSubject()))
-                                                               compareProps(s1.getObject(), s2.getObject());
+                                                       // Non literal properties.
+                                                       int comp = comparator.compare(g, s1.getObject(), s2.getObject());
+                                                       if (comp == ResourceComparator.NO_MATCH) {
+                                                               addModification(r1,s1,r2,s2);
+                                                       } else if (comp != ResourceComparator.EXACT_MATCH) {
+                                                               if (!s1.getObject().equals(s1.getSubject()) && !s2.getObject().equals(s2.getSubject())) {
+                                                                       if (!a1 && !a2) {
+                                                                               // compare props matches objects, so we can call that only for non asserted statements
+                                                                               compareProps(s1.getObject(), s2.getObject());
+                                                                       } else if (a1 && a2) {
+                                                                               // TODO : compare asserted statements?
+                                                                       } else {
+                                                                               addModification(r1,s1,r2,s2);
+                                                                       }
+                                                               } else {
+                                                                       addModification(r1,s1,r2,s2);
+                                                               }
+                                                       } else {
+                                                               // Exact match, nothing to do.
+                                                       }
                                                }
                                        } else {
                                                addModification(r1,s1,r2,s2);
-                                               if (!s1.isAsserted(r1) && !s2.isAsserted(r2))
-                                                       addComparable(s1, s2);
                                        }
                                        i1++;
                                        i2++;
@@ -1278,14 +1297,18 @@ public class GraphComparator {
                                }
                                case -1:{
                                        if (DEBUG) System.out.println("Compare Prop diff1s " + printStatement(g,s1));
-                                       addDeletion(s1);
+                                       // Use modification, since deletions do not support asserted statements
+                                       addModification(r1,s1,r2,null);
+                                       //addDeletion(s1);
                                        i1++;
                                        break;
                                }
                                        
                                case 1:{
                                        if (DEBUG) System.out.println("Compare Prop diff2s " + printStatement(g,s2));
-                                       addAddition(s2);
+                                       // Use modification, since additions do not support asserted statements
+                                       addModification(r1,null,r2,s2);
+                                       //addAddition(s2);
                                        i2++;
                                        break;
                                }