jena-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From a...@apache.org
Subject svn commit: r1621255 - /jena/trunk/jena-arq/src/test/java/com/hp/hpl/jena/sparql/algebra/optimize/TestTransformFilters.java
Date Fri, 29 Aug 2014 07:54:02 GMT
Author: andy
Date: Fri Aug 29 07:54:02 2014
New Revision: 1621255

URL: http://svn.apache.org/r1621255
Log:
Reformat

Modified:
    jena/trunk/jena-arq/src/test/java/com/hp/hpl/jena/sparql/algebra/optimize/TestTransformFilters.java

Modified: jena/trunk/jena-arq/src/test/java/com/hp/hpl/jena/sparql/algebra/optimize/TestTransformFilters.java
URL: http://svn.apache.org/viewvc/jena/trunk/jena-arq/src/test/java/com/hp/hpl/jena/sparql/algebra/optimize/TestTransformFilters.java?rev=1621255&r1=1621254&r2=1621255&view=diff
==============================================================================
--- jena/trunk/jena-arq/src/test/java/com/hp/hpl/jena/sparql/algebra/optimize/TestTransformFilters.java (original)
+++ jena/trunk/jena-arq/src/test/java/com/hp/hpl/jena/sparql/algebra/optimize/TestTransformFilters.java Fri Aug 29 07:54:02 2014
@@ -32,129 +32,113 @@ public class TestTransformFilters extend
     private Transform t_expandOneOf = new TransformExpandOneOf() ;
     private Transform t_implicitJoin = new TransformFilterImplicitJoin() ;
     private Transform t_implicitLeftJoin = new TransformImplicitLeftJoin() ;
-    
-    @Test public void equality01() 
-    {
+
+    @Test public void equality01()  {
         testOp("(filter (= ?x <x>) (bgp ( ?s ?p ?x)) )",
-             t_equality,
-             "(assign ((?x <x>)) (bgp ( ?s ?p <x>)) )") ;
+               t_equality,
+              "(assign ((?x <x>)) (bgp ( ?s ?p <x>)) )") ;
     }
-    
-    @Test public void equality02()
-    {
+
+    @Test public void equality02() {
         // Not safe on strings
         testOp("(filter (= ?x 'x') (bgp ( ?s ?p ?x)) )",
-             t_equality,
-             (String[])null) ;
+               t_equality,
+               (String[])null) ;
     }
 
-    @Test public void equality03()
-    {
+    @Test public void equality03() {
         // Not safe on numbers
         testOp("(filter (= ?x 123) (bgp ( ?s ?p ?x)) )",
-             t_equality,
-             (String[])null) ;
+               t_equality,
+               (String[])null) ;
     }
-    
-    @Test public void equality04()
-    {
+
+    @Test public void equality04() {
         // Unused
         testOp("(filter (= ?UNUSED <x>) (bgp ( ?s ?p ?x)) )",
-             t_equality,
-             "(table empty)") ;
+               t_equality,
+               "(table empty)") ;
     }
-    
-    @Test public void equality05()
-    {
+
+    @Test public void equality05() {
         // Can't optimize if filter does not cover vars in LHS 
         testOp("(filter (= ?x2 <x>) (conditional (bgp ( ?s1 ?p1 ?x1))  (bgp ( ?s2 ?p2 ?x2))))",
-             t_equality,
-             "(filter (= ?x2 <x>) (conditional (bgp ( ?s1 ?p1 ?x1))  (bgp ( ?s2 ?p2 ?x2))))") ;
+               t_equality,
+               "(filter (= ?x2 <x>) (conditional (bgp ( ?s1 ?p1 ?x1))  (bgp ( ?s2 ?p2 ?x2))))") ;
     }
-    
-    
-    @Test public void equality06()
-    {
+
+
+    @Test public void equality06() {
         testOp("(filter (= ?x <x>) (conditional (bgp ( ?s ?p ?x))  (bgp ( ?s ?p ?x))))",
-             t_equality,
-             "(assign((?x <x>)) (conditional (bgp ( ?s ?p <x>))  (bgp ( ?s ?p <x>))))") ;
+               t_equality,
+               "(assign((?x <x>)) (conditional (bgp ( ?s ?p <x>))  (bgp ( ?s ?p <x>))))") ;
     }
-    
-    @Test public void equality07()
-    {
+
+    @Test public void equality07() {
         testOp("(filter (= ?x <x>) (conditional (bgp ( ?s ?p ?x))  (bgp ( ?s ?p ?x1))))",
-             t_equality,
-             "(assign((?x <x>)) (conditional (bgp ( ?s ?p <x>))  (bgp ( ?s ?p ?x1))))") ;
+               t_equality,
+               "(assign((?x <x>)) (conditional (bgp ( ?s ?p <x>))  (bgp ( ?s ?p ?x1))))") ;
     }
-    
-    @Test public void equality08()
-    {
+
+    @Test public void equality08() {
         testOp("(filter (= ?x1 <x>) (conditional (bgp ( ?s ?p ?x))  (bgp ( ?s ?p ?x1))))",
-             t_equality,
-             "(filter (= ?x1 <x>) (conditional (bgp ( ?s ?p ?x))  (bgp ( ?s ?p ?x1))))") ;
+               t_equality,
+               "(filter (= ?x1 <x>) (conditional (bgp ( ?s ?p ?x))  (bgp ( ?s ?p ?x1))))") ;
     }
-    
-    @Test public void equality09()
-    {
+
+    @Test public void equality09() {
         // Can't optimize if filter does not cover vars in LHS 
         testOp("(filter (= ?x2 <x>) (leftjoin (bgp ( ?s1 ?p1 ?x1))  (bgp ( ?s2 ?p2 ?x2))))",
-             t_equality,
-             "(filter (= ?x2 <x>) (leftjoin (bgp ( ?s1 ?p1 ?x1))  (bgp ( ?s2 ?p2 ?x2))))") ;
+               t_equality,
+               "(filter (= ?x2 <x>) (leftjoin (bgp ( ?s1 ?p1 ?x1))  (bgp ( ?s2 ?p2 ?x2))))") ;
     }
-    
-    @Test public void equality10()
-    {
+
+    @Test public void equality10() {
         testOp("(filter (= ?x <x>) (leftjoin (bgp ( ?s ?p ?x))  (bgp ( ?s ?p ?x))))",
-             t_equality,
-             "(assign((?x <x>)) (leftjoin (bgp ( ?s ?p <x>))  (bgp ( ?s ?p <x>))))") ;
+               t_equality,
+               "(assign((?x <x>)) (leftjoin (bgp ( ?s ?p <x>))  (bgp ( ?s ?p <x>))))") ;
     }
-    
-    @Test public void equality11()
-    {
+
+    @Test public void equality11() {
         testOp("(filter (= ?x <x>) (leftjoin (bgp ( ?s ?p ?x))  (bgp ( ?s ?p ?x1))))",
-             t_equality,
-             "(assign((?x <x>)) (leftjoin (bgp ( ?s ?p <x>))  (bgp ( ?s ?p ?x1))))") ;
+               t_equality,
+               "(assign((?x <x>)) (leftjoin (bgp ( ?s ?p <x>))  (bgp ( ?s ?p ?x1))))") ;
     }
-    
-    @Test public void equality12()
-    {
+
+    @Test public void equality12() {
         testOp("(filter (= ?x1 <x>) (leftjoin (bgp ( ?s ?p ?x))  (bgp ( ?s ?p ?x1))))",
-             t_equality,
-             "(filter (= ?x1 <x>) (leftjoin (bgp ( ?s ?p ?x))  (bgp ( ?s ?p ?x1))))") ;
+               t_equality,
+               "(filter (= ?x1 <x>) (leftjoin (bgp ( ?s ?p ?x))  (bgp ( ?s ?p ?x1))))") ;
     }
 
-    @Test public void equality13()
-    {
+    @Test public void equality13() {
         testOp("(filter (= ?x1 <x>) (join (bgp ( ?s ?p ?x1))  (bgp ( ?s ?p ?x1))))",
-             t_equality,
-             "(assign((?x1 <x>))  (join (bgp ( ?s ?p <x>))  (bgp ( ?s ?p <x>))))") ;
+               t_equality,
+               "(assign((?x1 <x>))  (join (bgp ( ?s ?p <x>))  (bgp ( ?s ?p <x>))))") ;
     }
 
-    @Test public void equality14()
-    {
+    @Test public void equality14() {
         testOp("(filter (= ?x1 <x>) (union (bgp ( ?s ?p ?x1))  (bgp ( ?s ?p ?x1))))",
-             t_equality,
-             "(assign((?x1 <x>))  (union (bgp ( ?s ?p <x>))  (bgp ( ?s ?p <x>))))") ;
+               t_equality,
+               "(assign((?x1 <x>))  (union (bgp ( ?s ?p <x>))  (bgp ( ?s ?p <x>))))") ;
     }
 
-    @Test public void equality15()
-    {
+    @Test public void equality15() {
         // assign-push-in optimization.
         testOp("(filter (= ?x1 <x>) (leftjoin (leftjoin (table unit) (bgp ( ?s ?p ?x1)) ) (bgp ( ?s ?p ?x1)) ))", 
-             t_equality,
-             "(filter (= ?x1 <x>)", 
-             "   (leftjoin",
-             "     (leftjoin",
-             "       (table unit)", 
-             "       (assign ((?x1 <x>)) (bgp (triple ?s ?p <x>)))",
-             "     )",
-             "     (assign ((?x1 <x>)) (bgp (triple ?s ?p <x>)))",
-             "   ))" ) ;
+               t_equality,
+               "(filter (= ?x1 <x>)", 
+               "   (leftjoin",
+               "     (leftjoin",
+               "       (table unit)", 
+               "       (assign ((?x1 <x>)) (bgp (triple ?s ?p <x>)))",
+               "     )",
+               "     (assign ((?x1 <x>)) (bgp (triple ?s ?p <x>)))",
+            "   ))" ) ;
     }
-    
+
     // JENA-432 (simplified)
-    @Test public void equality16()
-    {
+    @Test public void equality16() {
         /*
         SELECT *
         WHERE {
@@ -167,26 +151,26 @@ public class TestTransformFilters extend
         } */
         String qs = StrUtils.strjoinNL
             ( "(filter (= ?test <http://localhost/t2>)"
-            , "  (leftjoin"
-            , "    (bgp (triple ?test ?p1 ?o1))"
-            , "      (project (?s1)"
-            , "       (bgp (triple ?s1 ?p2 ?o2)))))"
-            ) ;
+              , "  (leftjoin"
+              , "    (bgp (triple ?test ?p1 ?o1))"
+              , "      (project (?s1)"
+              , "       (bgp (triple ?s1 ?p2 ?o2)))))"
+                ) ;
         testOp(qs,
-             t_equality,
-             "(assign ((?test <http://localhost/t2>))" ,
-             "  (leftjoin" ,
-             "    (bgp (triple <http://localhost/t2> ?p1 ?o1))" ,
-             "    (project (?s1)" ,
-             "      (bgp (triple ?s1 ?p2 ?o2)))))"
+               t_equality,
+               "(assign ((?test <http://localhost/t2>))" ,
+               "  (leftjoin" ,
+               "    (bgp (triple <http://localhost/t2> ?p1 ?o1))" ,
+               "    (project (?s1)" ,
+               "      (bgp (triple ?s1 ?p2 ?o2)))))"
             ) ;
     }
-    
+
     @Test public void equality17() {
         // Conflicting constraints should result in no optimization
         testOp("(filter ((= ?x <http://constant1>) (= ?x <http://constant2>)) (join (bgp (?x <http://p1> ?o1)) (bgp (?x <http://p2> ?o2))))",
-             t_equality,
-             (String[])null);
+               t_equality,
+               (String[])null);
     }
 
     @Test public void optionalEqualitySubQuery_01() {
@@ -194,51 +178,51 @@ public class TestTransformFilters extend
         // (this is actually over cautious).
         String qs = StrUtils.strjoinNL
             ( "SELECT *"
-            , "WHERE {"
-            , "    ?test ?p1 ?X." 
-            , "    FILTER ( ?test = <http://localhost/t1> )"
-            , "    { SELECT ?s1 ?test { ?test ?p2 ?o2 } }"
-            , "}") ; 
-        
+              , "WHERE {"
+              , "    ?test ?p1 ?X." 
+              , "    FILTER ( ?test = <http://localhost/t1> )"
+              , "    { SELECT ?s1 ?test { ?test ?p2 ?o2 } }"
+              , "}") ; 
+
         String ops = StrUtils.strjoinNL
             ("(sequence"
-            ,"   (assign ((?test <http://localhost/t1>))"
-            ,"     (bgp (triple <http://localhost/t1> ?p1 ?X)))"
-            ,"   (project (?s1 ?test)"
-            ,"     (bgp (triple ?test ?/p2 ?/o2))))"
-            ) ;
+             ,"   (assign ((?test <http://localhost/t1>))"
+             ,"     (bgp (triple <http://localhost/t1> ?p1 ?X)))"
+             ,"   (project (?s1 ?test)"
+             ,"     (bgp (triple ?test ?/p2 ?/o2))))"
+                ) ;
         TestOptimizer.check(qs, ops) ;
     }
-    
+
     @Test public void optionalEqualitySubQuery_02() {
         String qs = StrUtils.strjoinNL
             ( "SELECT *"
-            , "WHERE {"
-            , "    ?test ?p1 ?X." 
-            , "    FILTER ( ?test = <http://localhost/t1> )"
-            , "    { SELECT ?s1 { ?test ?p2 ?o2 } }"
-            , "}") ;
+              , "WHERE {"
+              , "    ?test ?p1 ?X." 
+              , "    FILTER ( ?test = <http://localhost/t1> )"
+              , "    { SELECT ?s1 { ?test ?p2 ?o2 } }"
+              , "}") ;
         // JENA-616
         // Answer if FILTER equality done only after filter placement. 
         String ops = StrUtils.strjoinNL
             ( "(sequence"
-            , "  (assign ((?test <http://localhost/t1>))"
-            , "     (bgp (triple <http://localhost/t1> ?p1 ?X)))"
-            , "  (project (?s1)"
-            , "     (bgp (triple ?/test ?/p2 ?/o2))) )"
-            ) ;
+              , "  (assign ((?test <http://localhost/t1>))"
+              , "     (bgp (triple <http://localhost/t1> ?p1 ?X)))"
+              , "  (project (?s1)"
+              , "     (bgp (triple ?/test ?/p2 ?/o2))) )"
+                ) ;
         // Answer if weaker filter placement done, leaving the filter on the whole sequence. 
-//        String ops = StrUtils.strjoinNL
-//            ( "(assign ((?test <http://localhost/t1>))"
-//            , "  (sequence"
-//            , "    (bgp (triple <http://localhost/t1> ?p1 ?X))"
-//            , "    (project (?s1)"
-//            , "      (bgp (triple ?/test ?/p2 ?/o2)) )))"
-//            ) ;
-        
+        //        String ops = StrUtils.strjoinNL
+        //            ( "(assign ((?test <http://localhost/t1>))"
+        //            , "  (sequence"
+        //            , "    (bgp (triple <http://localhost/t1> ?p1 ?X))"
+        //            , "    (project (?s1)"
+        //            , "      (bgp (triple ?/test ?/p2 ?/o2)) )))"
+        //            ) ;
+
         TestOptimizer.check(qs, ops) ;
     }
-    
+
     // JENA-383, simplified.
     @Test public void optionalEquality_01() {
         // Not optimized because the TransformFilterEquality does not notice
@@ -251,15 +235,15 @@ public class TestTransformFilters extend
               , "}"
                 ) ;
         // Answer if weaker filter placement done, leaving the filter on the whole sequence. JENA-671
-//        String ops = StrUtils.strjoinNL
-//            ( "(filter (= ?x <http://example/x>)"
-//            , "  (sequence"
-//            , "     (conditional"
-//            , "        (table unit)"
-//            , "        (bgp (triple ?x <http://example/q> ?o)))"
-//            , "     (bgp (triple ?x <http://example/p> ?o2))"
-//            , " ))" 
-//            ) ;
+        //        String ops = StrUtils.strjoinNL
+        //            ( "(filter (= ?x <http://example/x>)"
+        //            , "  (sequence"
+        //            , "     (conditional"
+        //            , "        (table unit)"
+        //            , "        (bgp (triple ?x <http://example/q> ?o)))"
+        //            , "     (bgp (triple ?x <http://example/p> ?o2))"
+        //            , " ))" 
+        //            ) ;
         //JENA-671
         String ops = StrUtils.strjoinNL
             ("(sequence"
@@ -273,7 +257,7 @@ public class TestTransformFilters extend
 
         TestOptimizer.check(qs, ops) ;
     }
-    
+
     @Test public void optionalEqualityScope_01() {
         String qs = StrUtils.strjoinNL
             ( "PREFIX : <http://example/> SELECT * {"
@@ -286,24 +270,24 @@ public class TestTransformFilters extend
         // Weaker placement.
         String ops = StrUtils.strjoinNL
             ("(assign ((?x <http://example/x>))"
-            , "   (sequence"
-            , "       (conditional"
-            , "         (table unit)"
-            , "         (bgp (triple <http://example/x> <http://example/q> ?o)))"
-            , "       (bgp (triple <http://example/x> <http://example/p> ?o2))))"
-            ) ;
+             , "   (sequence"
+             , "       (conditional"
+             , "         (table unit)"
+             , "         (bgp (triple <http://example/x> <http://example/q> ?o)))"
+             , "       (bgp (triple <http://example/x> <http://example/p> ?o2))))"
+                ) ;
         //JENA-671
         // Note that "assign" is a filter as well
         // so it filters the ?x fro the RHS of the conditional.
         String ops2 = StrUtils.strjoinNL
             ("(sequence"
-            ,"  (conditional"
-            ,"    (table unit)"
-            ,"    (bgp (triple ?x <http://example/q> ?o)) )"
-            ,"  (assign ((?x <http://example/x>))"
-            ,"    (bgp (triple <http://example/x> <http://example/p> ?o2)))"
-            ,"  )"     
-            ) ;
+             ,"  (conditional"
+             ,"    (table unit)"
+             ,"    (bgp (triple ?x <http://example/q> ?o)) )"
+             ,"  (assign ((?x <http://example/x>))"
+             ,"    (bgp (triple <http://example/x> <http://example/p> ?o2)))"
+             ,"  )"     
+                ) ;
         TestOptimizer.check(qs, ops2) ;
     }
 
@@ -321,23 +305,23 @@ public class TestTransformFilters extend
         // Answer if FILTER equality optimization done only after FILTER placement.
         String ops = StrUtils.strjoinNL
             ( "(conditional"
-            , "  (assign ((?x <http://example/x>))"
-            , "     (bgp (triple <http://example/x> <http://example/p> ?o2)))"
-            , "  (bgp (triple ?x <http://example/q> ?o))"
-            , "  )"
-            ) ;
+              , "  (assign ((?x <http://example/x>))"
+              , "     (bgp (triple <http://example/x> <http://example/p> ?o2)))"
+              , "  (bgp (triple ?x <http://example/q> ?o))"
+              , "  )"
+                ) ;
         // Answer if FILTER equality optimization done before FILTER placement
         // (and possible afterwards as well).
-//        String ops = StrUtils.strjoinNL
-//            ( "(assign ((?x <http://example/x>))"
-//            , "  (conditional"
-//            , "    (bgp (triple <http://example/x> <http://example/p> ?o2))"
-//            , "    (bgp (triple <http://example/x> <http://example/q> ?o))"
-//            , "  ))"
-//            ) ;
+        //        String ops = StrUtils.strjoinNL
+        //            ( "(assign ((?x <http://example/x>))"
+        //            , "  (conditional"
+        //            , "    (bgp (triple <http://example/x> <http://example/p> ?o2))"
+        //            , "    (bgp (triple <http://example/x> <http://example/q> ?o))"
+        //            , "  ))"
+        //            ) ;
         TestOptimizer.check(qs, ops) ;
     }
-    
+
     // JENA-294 part II
     @Test public void optionalEqualityScope_03() {
         String qs = StrUtils.strjoinNL
@@ -350,11 +334,11 @@ public class TestTransformFilters extend
         // Unsafe to transform:  ?x is optional. 
         String ops = StrUtils.strjoinNL
             ( "(filter (= ?x <http://example/x>)"
-            , "   (conditional"
-            , "     (bgp (triple ?z <http://example/p> ?o2))"
-            , "     (bgp (triple ?x <http://example/q> ?o))"
-            , "))"
-            ) ;
+              , "   (conditional"
+              , "     (bgp (triple ?z <http://example/p> ?o2))"
+              , "     (bgp (triple ?x <http://example/q> ?o))"
+              , "))"
+                ) ;
         TestOptimizer.check(qs, ops) ;
     }
 
@@ -369,113 +353,103 @@ public class TestTransformFilters extend
         // Unsafe to transform:  This may not defined ?x, then FILTER -> unbound -> error -> false
         String ops1 = StrUtils.strjoinNL
             ("(filter (= ?x <http://example/x>)"
-            ,"    (conditional"
-            ,"      (table unit)"
-            ,"      (assign ((?x <http://example/x>))"
-            ,"        (bgp (triple <http://example/x> <http://example/q> ?o)))))"
-            ) ;
-        
+             ,"    (conditional"
+             ,"      (table unit)"
+             ,"      (assign ((?x <http://example/x>))"
+             ,"        (bgp (triple <http://example/x> <http://example/q> ?o)))))"
+                ) ;
+
         TestOptimizer.check(qs, ops1) ;
     }
 
-    
-    @Test public void disjunction01()
-    {
+
+    @Test public void disjunction01() {
         testOp("(filter (|| (= ?x <x>) (= ?x <y>)) (bgp ( ?s ?p ?x)) )",
-             t_disjunction,
-             "(disjunction ",
+               t_disjunction,
+               "(disjunction ",
                "(assign ((?x <x>)) (bgp ( ?s ?p <x>)))",
                "(assign ((?x <y>)) (bgp ( ?s ?p <y>)))",
-             ")") ;
+            ")") ;
     }
-    
-    @Test public void disjunction02()
-    {
+
+    @Test public void disjunction02() {
         testOp("(filter (|| (= ?x <x>) (!= ?x <y>)) (bgp ( ?s ?p ?x)) )",
-             t_disjunction,
-             "(disjunction ",
+               t_disjunction,
+               "(disjunction ",
                "(assign ((?x <x>)) (bgp ( ?s ?p <x>)))",
                "(filter (!= ?x <y>) (bgp ( ?s ?p ?x)))",
-             ")") ;
+            ")") ;
     }
-    
-    @Test public void disjunction03()
-    {
+
+    @Test public void disjunction03() {
         testOp("(filter (|| (!= ?x <x>) (= ?x <y>)) (bgp ( ?s ?p ?x)) )",
-             t_disjunction,
-             // Note - reording of disjunction terms.
-             "(disjunction ",
+               t_disjunction,
+               // Note - reording of disjunction terms.
+               "(disjunction ",
                "(assign ((?x <y>)) (bgp ( ?s ?p <y>)))",
                "(filter (!= ?x <x>) (bgp ( ?s ?p ?x)))",
-             ")") ;
+            ")") ;
     }
-    
-    @Test public void disjunction04()
-    {
+
+    @Test public void disjunction04() {
         testOp("(filter (|| (!= ?x <y>) (!= ?x <x>)) (bgp ( ?s ?p ?x)) )",
-             t_disjunction,
-             (String[])null) ;
+               t_disjunction,
+               (String[])null) ;
     }
 
-    @Test public void disjunction05()
-    {
+    @Test public void disjunction05() {
         testOp("(filter (exprlist (|| (= ?x <y>) (!= ?x <x>)))    (bgp ( ?s ?p ?x)) )",
-             t_disjunction,
-             "  (disjunction",
-             "    (assign ((?x <y>)) (bgp ( ?s ?p <y>)))",
-             "    (filter (!= ?x <x>) (bgp ( ?s ?p ?x)))",
-             ")"
-        ) ;
+               t_disjunction,
+               "  (disjunction",
+               "    (assign ((?x <y>)) (bgp ( ?s ?p <y>)))",
+               "    (filter (!= ?x <x>) (bgp ( ?s ?p ?x)))",
+               ")"
+            ) ;
     }
 
-    @Test public void disjunction06()
-    {
+    @Test public void disjunction06() {
         testOp("(filter (exprlist (lang ?x) (|| (= ?x <y>) (!= ?x <x>)))    (bgp ( ?s ?p ?x)) )",
-             t_disjunction,
-             "(filter (lang ?x)",   
-             "  (disjunction",
-             "    (assign ((?x <y>)) (bgp ( ?s ?p <y>)))",
-             "    (filter (!= ?x <x>) (bgp ( ?s ?p ?x)))",
-             "))"
-        ) ;
-    }
-    
-    @Test public void disjunction07()
-    {
+               t_disjunction,
+               "(filter (lang ?x)",   
+               "  (disjunction",
+               "    (assign ((?x <y>)) (bgp ( ?s ?p <y>)))",
+               "    (filter (!= ?x <x>) (bgp ( ?s ?p ?x)))",
+               "))"
+            ) ;
+    }
+
+    @Test public void disjunction07() {
         testOp("(filter (exprlist (|| (= ?x <y>) (!= ?x <x>)) (lang ?x) )    (bgp ( ?s ?p ?x)) )",
-             t_disjunction,
-             "(filter (lang ?x)",   
-             "  (disjunction",
-             "    (assign ((?x <y>)) (bgp ( ?s ?p <y>)))",
-             "    (filter (!= ?x <x>) (bgp ( ?s ?p ?x)))",
-             "))"
-        ) ;
+               t_disjunction,
+               "(filter (lang ?x)",   
+               "  (disjunction",
+               "    (assign ((?x <y>)) (bgp ( ?s ?p <y>)))",
+               "    (filter (!= ?x <x>) (bgp ( ?s ?p ?x)))",
+               "))"
+            ) ;
     }
 
-    @Test public void oneOf1()
-    {
+    @Test public void oneOf1() {
         testOp(
-             "(filter (in ?x <x> 2 3) (bgp (?s ?p ?x)))",
-             t_expandOneOf,
-             "(filter (|| ( || (= ?x <x>) (= ?x 2)) (= ?x 3)) (bgp (?s ?p ?x)))") ;
+               "(filter (in ?x <x> 2 3) (bgp (?s ?p ?x)))",
+               t_expandOneOf,
+               "(filter (|| ( || (= ?x <x>) (= ?x 2)) (= ?x 3)) (bgp (?s ?p ?x)))") ;
     }
 
-    @Test public void oneOf2()
-    {
+    @Test public void oneOf2() {
         testOp(
-             "(filter (exprlist (= ?x 99) (in ?x <x> 2 3)) (bgp (?s ?p ?x)))",
-             t_expandOneOf,
-             "(filter (exprlist (= ?x 99) (|| ( || (= ?x <x>) (= ?x 2)) (= ?x 3))) (bgp (?s ?p ?x)))") ;
+               "(filter (exprlist (= ?x 99) (in ?x <x> 2 3)) (bgp (?s ?p ?x)))",
+               t_expandOneOf,
+               "(filter (exprlist (= ?x 99) (|| ( || (= ?x <x>) (= ?x 2)) (= ?x 3))) (bgp (?s ?p ?x)))") ;
     }
-    
-    @Test public void oneOf3()
-    {
+
+    @Test public void oneOf3() {
         testOp(
-             "(filter (notin ?x <x> 2 3) (bgp (?s ?p ?x)))",
-             t_expandOneOf,
-             "(filter (exprlist (!= ?x <x>) (!= ?x 2) (!= ?x 3)) (bgp (?s ?p ?x)))") ;
+               "(filter (notin ?x <x> 2 3) (bgp (?s ?p ?x)))",
+               t_expandOneOf,
+               "(filter (exprlist (!= ?x <x>) (!= ?x 2) (!= ?x 3)) (bgp (?s ?p ?x)))") ;
     }
-    
+
     @Test
     public void oneOf4() {
         // JENA-771
@@ -492,605 +466,551 @@ public class TestTransformFilters extend
                "(filter true (distinct (filter (exprlist (!= ?x 1) (!= ?x 2)) (bgp (triple ?s ?p ?x)) )))") ;
     }
 
-    @Test public void implicitJoin01()
-    {
+    @Test public void implicitJoin01() {
+        testOp(
+               "(filter (= ?x ?y) (bgp (?x ?p ?o)(?y ?p1 ?o1)))",
+               t_implicitJoin,
+               "(assign ((?x ?y)) (bgp (?y ?p ?o)(?y ?p1 ?o1)))");
+    }
+
+    @Test public void implicitJoin02() {
         testOp(
-             "(filter (= ?x ?y) (bgp (?x ?p ?o)(?y ?p1 ?o1)))",
-             t_implicitJoin,
-             "(assign ((?x ?y)) (bgp (?y ?p ?o)(?y ?p1 ?o1)))");
-    }
-    
-    @Test public void implicitJoin02()
-    {
-        testOp(
-             "(filter (= ?x ?y) (bgp (?x ?p ?o)))",
-             t_implicitJoin,
-             "(table empty)");
-    }
-    
-    @Test public void implicitJoin03()
-    {
+               "(filter (= ?x ?y) (bgp (?x ?p ?o)))",
+               t_implicitJoin,
+               "(table empty)");
+    }
+
+    @Test public void implicitJoin03() {
         // Still safe to transform as at least one is guaranteed non-literal
         testOp(
-             "(filter (= ?x ?y) (bgp (?x ?p ?o)(?a ?b ?y)))",
-             t_implicitJoin,
-             "(assign ((?x ?y)) (bgp (?y ?p ?o)(?a ?b ?y)))");
-    }
-    
-    @Test public void implicitJoin04()
-    {
+               "(filter (= ?x ?y) (bgp (?x ?p ?o)(?a ?b ?y)))",
+               t_implicitJoin,
+               "(assign ((?x ?y)) (bgp (?y ?p ?o)(?a ?b ?y)))");
+    }
+
+    @Test public void implicitJoin04() {
         // Not safe to transform as both may be literals
         testOp(
-             "(filter (= ?x ?y) (bgp (?a ?b ?x)(?c ?d ?y)))",
-             t_implicitJoin,
-             "(filter (= ?x ?y) (bgp (?a ?b ?x)(?c ?d ?y)))");
-    }
-    
-    @Test public void implicitJoin05()
-    {
+               "(filter (= ?x ?y) (bgp (?a ?b ?x)(?c ?d ?y)))",
+               t_implicitJoin,
+               "(filter (= ?x ?y) (bgp (?a ?b ?x)(?c ?d ?y)))");
+    }
+
+    @Test public void implicitJoin05() {
         // Safe to transform as although both may be literals we are using sameTerm so already relying on term equality
         testOp(
-             "(filter (sameTerm ?x ?y) (bgp (?a ?b ?x)(?c ?d ?y)))",
-             t_implicitJoin,
-             "(assign ((?x ?y)) (bgp (?a ?b ?y)(?c ?d ?y)))");
-    }
-    
-    @Test public void implicitJoin06()
-    {
+               "(filter (sameTerm ?x ?y) (bgp (?a ?b ?x)(?c ?d ?y)))",
+               t_implicitJoin,
+               "(assign ((?x ?y)) (bgp (?a ?b ?y)(?c ?d ?y)))");
+    }
+
+    @Test public void implicitJoin06() {
         // Not safe to transform as equality on same variable
         testOp(
-             "(filter (= ?x ?x) (bgp (?x ?p ?o)(?y ?p1 ?o1)))",
-             t_implicitJoin,
-             (String[])null);
-    }
-    
-    @Test public void implicitJoin07()
-    {
-        testOp(
-             "(filter ((= ?x ?y) (= ?x ?z)) (bgp (?x ?p ?o)(?y ?p1 ?z)))",
-             t_implicitJoin,
-             (String[])null);
-    }
-    
-    @Test public void implicitJoin08()
-    {
-        testOp(
-             "(filter (= ?x ?y) (join (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1))))",
-             t_implicitJoin,
-             "(assign ((?x ?y)) (join (bgp (?y ?p ?o)) (bgp (?y ?p1 ?o1))))");
-        
-        testOp(
-                "(filter (= ?y ?x) (join (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1))))",
-                t_implicitJoin,
-                "(assign ((?y ?x)) (join (bgp (?x ?p ?o)) (bgp (?x ?p1 ?o1))))");
-    }
-    
-    @Test public void implicitJoin09()
-    {
+               "(filter (= ?x ?x) (bgp (?x ?p ?o)(?y ?p1 ?o1)))",
+               t_implicitJoin,
+               (String[])null);
+    }
+
+    @Test public void implicitJoin07() {
+        testOp(
+               "(filter ((= ?x ?y) (= ?x ?z)) (bgp (?x ?p ?o)(?y ?p1 ?z)))",
+               t_implicitJoin,
+               (String[])null);
+    }
+
+    @Test public void implicitJoin08() {
+        testOp(
+               "(filter (= ?x ?y) (join (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1))))",
+               t_implicitJoin,
+               "(assign ((?x ?y)) (join (bgp (?y ?p ?o)) (bgp (?y ?p1 ?o1))))");
+
+        testOp(
+               "(filter (= ?y ?x) (join (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1))))",
+               t_implicitJoin,
+               "(assign ((?y ?x)) (join (bgp (?x ?p ?o)) (bgp (?x ?p1 ?o1))))");
+    }
+
+    @Test public void implicitJoin09() {
         // A variable introduced by an assign cannot be considered safe
         testOp(
-             "(filter (= ?x ?y) (assign ((?x <http://constant>)) (bgp (?y ?p ?o))))",
-             t_implicitJoin,
-             (String[])null);
-    }
-    
-    @Test public void implicitJoin10()
-    {
+               "(filter (= ?x ?y) (assign ((?x <http://constant>)) (bgp (?y ?p ?o))))",
+               t_implicitJoin,
+               (String[])null);
+    }
+
+    @Test public void implicitJoin10() {
         // A variable not necessarily fixed makes the transform unsafe
         testOp(
-            "(filter (= ?x ?y) (leftjoin (leftjoin (bgp (?s <http://pred> ?o)) (bgp (?x ?p ?o))) (bgp (?y ?p1 ?o1))))",
-            t_implicitJoin,
-            (String[])null);
-    }
-    
-    @Test public void implictJoin11()
-    {
+               "(filter (= ?x ?y) (leftjoin (leftjoin (bgp (?s <http://pred> ?o)) (bgp (?x ?p ?o))) (bgp (?y ?p1 ?o1))))",
+               t_implicitJoin,
+               (String[])null);
+    }
+
+    @Test public void implictJoin11() {
         // Test case related to JENA-500
         // Detect that the expression (= ?prebound ?y) is always 'error' because 
         // ?prebound is undef.  Therefore the whole thing can be removed as there
         // can be no solutions.
         testOp(
-            "(filter (= ?prebound ?y) (extend ((?y (ex:someFunction ?x))) (table unit)))",
-            t_implicitJoin,
-            "(table empty)");
-    }
-    
-    @Test public void implicitJoin12()
-    {
-    	// Test case from JENA-692
-    	// Implicit join should not apply to the whole union because the variables involved aren't fixed
-    	// However we can spot the special case of one branch of the union being invalid and throw it out
-    	testOp(
-			"(filter (= ?a ?b) (union (bgp (triple ?a :p :o1)) (bgp (triple ?b :p ?a))))", 
-			t_implicitJoin,
-			"(assign ((?a ?b)) (bgp (triple ?b :p ?b)))");
-    }
-    
-    @Test public void implicitJoin13()
-    {
-    	// Variation on test case from JENA-692
-    	// Implicit join should not apply to the whole union because the variables involved aren't fixed
-    	// However we can spot the special case of one branch of the union being invalid and throw it out
-    	testOp(
-			"(filter (= ?a ?b) (union (bgp (triple ?b :p ?a)) (bgp (triple ?a :p :o1))))", 
-			t_implicitJoin,
-			"(assign ((?a ?b)) (bgp (triple ?b :p ?b)))");
-    }
-    
-    @Test public void implicitJoin14()
-    {
-    	// Variation on test case from JENA-692
-    	// Implicit join should not apply to the whole union because the variables involved aren't fixed
-    	// However we can spot the special case where both branches are invalid
-    	testOp(
-			"(filter (= ?a ?b) (union (bgp (triple ?b :p :o1)) (bgp (triple ?a :p :o2))))", 
-			t_implicitJoin,
-			"(table empty)");
-    }
-        
-    @Test public void implicitJoin15()
-    {
-    	// Variation on the test case from JENA-692 with additional assignment added
-    	// Implicit join should not apply to the whole union because not all assignments are valid
-    	testOp(
-			"(filter ((= ?a ?b) (= ?a ?p)) (union (bgp (triple ?a ?p :o1)) (bgp (triple ?b ?p ?a))))", 
-			t_implicitJoin,
-			(String[])null);
-    }
-    
-    @Test public void implicitJoin16()
-    {
-    	// Variation on test case from JENA-692
-    	// Implicit join can apply because assignments are valid over both branches of the union
-    	testOp(
-			"(filter (= ?a ?b) (union (bgp (triple ?a :p ?b)) (bgp (triple ?b :p ?a))))", 
-			t_implicitJoin,
-			"(assign ((?a ?b)) (union (bgp (triple ?b :p ?b)) (bgp (triple ?b :p ?b))))");
-    }
-    
-    @Test public void implicitJoin17()
-    {
-    	// Variation on test case from JENA-692
-    	// Implicit join can apply because the filter is over the branch of the union where it is valid
-    	testOp(
-			"(union (bgp (triple ?a :p :o1)) (filter (= ?a ?b) (bgp (triple ?b :p ?a))))", 
-			t_implicitJoin,
-			"(union (bgp (triple ?a :p :o1)) (assign ((?a ?b)) (bgp (triple ?b :p ?b))))");
-    }
-        
-    @Test public void implicitLeftJoin01()
-    {
+               "(filter (= ?prebound ?y) (extend ((?y (ex:someFunction ?x))) (table unit)))",
+               t_implicitJoin,
+               "(table empty)");
+    }
+
+    @Test public void implicitJoin12() {
+        // Test case from JENA-692
+        // Implicit join should not apply to the whole union because the variables involved aren't fixed
+        // However we can spot the special case of one branch of the union being invalid and throw it out
+        testOp(
+               "(filter (= ?a ?b) (union (bgp (triple ?a :p :o1)) (bgp (triple ?b :p ?a))))", 
+               t_implicitJoin,
+               "(assign ((?a ?b)) (bgp (triple ?b :p ?b)))");
+    }
+
+    @Test public void implicitJoin13() {
+        // Variation on test case from JENA-692
+        // Implicit join should not apply to the whole union because the variables involved aren't fixed
+        // However we can spot the special case of one branch of the union being invalid and throw it out
+        testOp(
+               "(filter (= ?a ?b) (union (bgp (triple ?b :p ?a)) (bgp (triple ?a :p :o1))))", 
+               t_implicitJoin,
+               "(assign ((?a ?b)) (bgp (triple ?b :p ?b)))");
+    }
+
+    @Test public void implicitJoin14() {
+        // Variation on test case from JENA-692
+        // Implicit join should not apply to the whole union because the variables involved aren't fixed
+        // However we can spot the special case where both branches are invalid
+        testOp(
+               "(filter (= ?a ?b) (union (bgp (triple ?b :p :o1)) (bgp (triple ?a :p :o2))))", 
+               t_implicitJoin,
+               "(table empty)");
+    }
+
+    @Test public void implicitJoin15() {
+        // Variation on the test case from JENA-692 with additional assignment added
+        // Implicit join should not apply to the whole union because not all assignments are valid
+        testOp(
+               "(filter ((= ?a ?b) (= ?a ?p)) (union (bgp (triple ?a ?p :o1)) (bgp (triple ?b ?p ?a))))", 
+               t_implicitJoin,
+               (String[])null);
+    }
+
+    @Test public void implicitJoin16() {
+        // Variation on test case from JENA-692
+        // Implicit join can apply because assignments are valid over both branches of the union
+        testOp(
+               "(filter (= ?a ?b) (union (bgp (triple ?a :p ?b)) (bgp (triple ?b :p ?a))))", 
+               t_implicitJoin,
+               "(assign ((?a ?b)) (union (bgp (triple ?b :p ?b)) (bgp (triple ?b :p ?b))))");
+    }
+
+    @Test public void implicitJoin17() {
+        // Variation on test case from JENA-692
+        // Implicit join can apply because the filter is over the branch of the union where it is valid
+        testOp(
+               "(union (bgp (triple ?a :p :o1)) (filter (= ?a ?b) (bgp (triple ?b :p ?a))))", 
+               t_implicitJoin,
+               "(union (bgp (triple ?a :p :o1)) (assign ((?a ?b)) (bgp (triple ?b :p ?b))))");
+    }
+
+    @Test public void implicitLeftJoin01() {
         // Possible to optimize some cases where it's an implicit left join
-        
+
         // Covers the case with one variable on left and other on right
         testOp(
-             "(leftjoin (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1)) ((= ?x ?y)))",
-             t_implicitLeftJoin,
-             "(leftjoin (bgp (?x ?p ?o)) (assign ((?y ?x)) (bgp (?x ?p1 ?o1))))");
-        
+               "(leftjoin (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1)) ((= ?x ?y)))",
+               t_implicitLeftJoin,
+               "(leftjoin (bgp (?x ?p ?o)) (assign ((?y ?x)) (bgp (?x ?p1 ?o1))))");
+
         // Swapping the order of the equality expression should make no difference
         testOp(
-                "(leftjoin (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1)) ((= ?y ?x)))",
-                t_implicitLeftJoin,
-                "(leftjoin (bgp (?x ?p ?o)) (assign ((?y ?x)) (bgp (?x ?p1 ?o1))))");
-    }
-    
-    @Test public void implicitLeftJoin02()
-    {
+               "(leftjoin (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1)) ((= ?y ?x)))",
+               t_implicitLeftJoin,
+               "(leftjoin (bgp (?x ?p ?o)) (assign ((?y ?x)) (bgp (?x ?p1 ?o1))))");
+    }
+
+    @Test public void implicitLeftJoin02() {
         // Possible to optimize some cases where it's an implicit left join
-        
+
         // Covers the case with one variable on left and other on right
         testOp(
-             "(leftjoin (bgp (?y ?p ?o)) (bgp (?x ?p1 ?o1)) ((= ?x ?y)))",
-             t_implicitLeftJoin,
-             "(leftjoin (bgp (?y ?p ?o)) (assign ((?x ?y)) (bgp (?y ?p1 ?o1))))");
-        
+               "(leftjoin (bgp (?y ?p ?o)) (bgp (?x ?p1 ?o1)) ((= ?x ?y)))",
+               t_implicitLeftJoin,
+               "(leftjoin (bgp (?y ?p ?o)) (assign ((?x ?y)) (bgp (?y ?p1 ?o1))))");
+
         // Swapping the order of the equality expression should make no difference
         testOp(
-                "(leftjoin (bgp (?y ?p ?o)) (bgp (?x ?p1 ?o1)) ((= ?y ?x)))",
-                t_implicitLeftJoin,
-                "(leftjoin (bgp (?y ?p ?o)) (assign ((?x ?y)) (bgp (?y ?p1 ?o1))))");
-    }
-    
-    @Test public void implicitLeftJoin03()
-    {
+               "(leftjoin (bgp (?y ?p ?o)) (bgp (?x ?p1 ?o1)) ((= ?y ?x)))",
+               t_implicitLeftJoin,
+               "(leftjoin (bgp (?y ?p ?o)) (assign ((?x ?y)) (bgp (?y ?p1 ?o1))))");
+    }
+
+    @Test public void implicitLeftJoin03() {
         // Possible to optimize some cases where it's an implicit left join
-        
+
         // Covers the case with one variable on left and both on right
         testOp(
-             "(leftjoin (bgp (?x ?p ?o)) (bgp (?x <http://type> ?type)(?y ?p1 ?o1)) ((= ?x ?y)))",
-             t_implicitLeftJoin,
-             "(leftjoin (bgp (?x ?p ?o)) (assign ((?y ?x)) (bgp (?x <http://type> ?type)(?x ?p1 ?o1))))");
-        
+               "(leftjoin (bgp (?x ?p ?o)) (bgp (?x <http://type> ?type)(?y ?p1 ?o1)) ((= ?x ?y)))",
+               t_implicitLeftJoin,
+               "(leftjoin (bgp (?x ?p ?o)) (assign ((?y ?x)) (bgp (?x <http://type> ?type)(?x ?p1 ?o1))))");
+
         // Swapping the order of the equality expression should make no difference
         testOp(
-                "(leftjoin (bgp (?x ?p ?o)) (bgp (?x <http://type> ?type)(?y ?p1 ?o1)) ((= ?y ?x)))",
-                t_implicitLeftJoin,
-                "(leftjoin (bgp (?x ?p ?o)) (assign ((?y ?x)) (bgp (?x <http://type> ?type)(?x ?p1 ?o1))))");
-    }
-    
-    @Test public void implicitLeftJoin04()
-    {
+               "(leftjoin (bgp (?x ?p ?o)) (bgp (?x <http://type> ?type)(?y ?p1 ?o1)) ((= ?y ?x)))",
+               t_implicitLeftJoin,
+               "(leftjoin (bgp (?x ?p ?o)) (assign ((?y ?x)) (bgp (?x <http://type> ?type)(?x ?p1 ?o1))))");
+    }
+
+    @Test public void implicitLeftJoin04() {
         // Possible to optimize some cases where it's an implicit left join
-        
+
         // Covers the case with one variable on left and both on right
         testOp(
-             "(leftjoin (bgp (?y ?p ?o)) (bgp (?x <http://type> ?type)(?y ?p1 ?o1)) ((= ?x ?y)))",
-             t_implicitLeftJoin,
-             "(leftjoin (bgp (?y ?p ?o)) (assign ((?x ?y)) (bgp (?y <http://type> ?type)(?y ?p1 ?o1))))");
-        
+               "(leftjoin (bgp (?y ?p ?o)) (bgp (?x <http://type> ?type)(?y ?p1 ?o1)) ((= ?x ?y)))",
+               t_implicitLeftJoin,
+               "(leftjoin (bgp (?y ?p ?o)) (assign ((?x ?y)) (bgp (?y <http://type> ?type)(?y ?p1 ?o1))))");
+
         // Swapping the order of the equality expression should make no difference
         testOp(
-                "(leftjoin (bgp (?y ?p ?o)) (bgp (?x <http://type> ?type)(?y ?p1 ?o1)) ((= ?y ?x)))",
-                t_implicitLeftJoin,
-                "(leftjoin (bgp (?y ?p ?o)) (assign ((?x ?y)) (bgp (?y <http://type> ?type)(?y ?p1 ?o1))))");
-    }
-    
-    @Test public void implicitLeftJoin05()
-    {
+               "(leftjoin (bgp (?y ?p ?o)) (bgp (?x <http://type> ?type)(?y ?p1 ?o1)) ((= ?y ?x)))",
+               t_implicitLeftJoin,
+               "(leftjoin (bgp (?y ?p ?o)) (assign ((?x ?y)) (bgp (?y <http://type> ?type)(?y ?p1 ?o1))))");
+    }
+
+    @Test public void implicitLeftJoin05() {
         // Possible to optimize some cases where it's an implicit left join
-        
+
         // Covers the case of both variables on left and only one on right
         testOp(
-             "(leftjoin (bgp (?x ?p ?o)(?x <http://pred> ?y)) (bgp (?y ?p1 ?o1)) ((= ?x ?y)))",
-             t_implicitLeftJoin,
-             "(leftjoin (bgp (?x ?p ?o)(?x <http://pred> ?y)) (assign ((?y ?x)) (bgp (?x ?p1 ?o1))))");
-        
+               "(leftjoin (bgp (?x ?p ?o)(?x <http://pred> ?y)) (bgp (?y ?p1 ?o1)) ((= ?x ?y)))",
+               t_implicitLeftJoin,
+               "(leftjoin (bgp (?x ?p ?o)(?x <http://pred> ?y)) (assign ((?y ?x)) (bgp (?x ?p1 ?o1))))");
+
         // Swapping the order of the equality expression should make no difference
         testOp(
-                "(leftjoin (bgp (?x ?p ?o)(?x <http://pred> ?y)) (bgp (?y ?p1 ?o1)) ((= ?y ?x)))",
-                t_implicitLeftJoin,
-                "(leftjoin (bgp (?x ?p ?o)(?x <http://pred> ?y)) (assign ((?y ?x)) (bgp (?x ?p1 ?o1))))");
-    }
-    
-    @Test public void implicitLeftJoin06()
-    {
+               "(leftjoin (bgp (?x ?p ?o)(?x <http://pred> ?y)) (bgp (?y ?p1 ?o1)) ((= ?y ?x)))",
+               t_implicitLeftJoin,
+               "(leftjoin (bgp (?x ?p ?o)(?x <http://pred> ?y)) (assign ((?y ?x)) (bgp (?x ?p1 ?o1))))");
+    }
+
+    @Test public void implicitLeftJoin06() {
         // Possible to optimize some cases where it's an implicit left join
-        
+
         // Covers the case of both variables on left and only one on right
         testOp(
-             "(leftjoin (bgp (?x ?p ?o)(?x <http://pred> ?y)) (bgp (?x ?p1 ?o1)) ((= ?x ?y)))",
-             t_implicitLeftJoin,
-             "(leftjoin (bgp (?x ?p ?o)(?x <http://pred> ?y)) (assign ((?x ?y)) (bgp (?y ?p1 ?o1))))");
-        
+               "(leftjoin (bgp (?x ?p ?o)(?x <http://pred> ?y)) (bgp (?x ?p1 ?o1)) ((= ?x ?y)))",
+               t_implicitLeftJoin,
+               "(leftjoin (bgp (?x ?p ?o)(?x <http://pred> ?y)) (assign ((?x ?y)) (bgp (?y ?p1 ?o1))))");
+
         // Swapping the order of the equality expression should make no difference
-        testOp(
-                "(leftjoin (bgp (?x ?p ?o)(?x <http://pred> ?y)) (bgp (?x ?p1 ?o1)) ((= ?y ?x)))",
-                t_implicitLeftJoin,
-                "(leftjoin (bgp (?x ?p ?o)(?x <http://pred> ?y)) (assign ((?x ?y)) (bgp (?y ?p1 ?o1))))");
-    }
-    
-    @Test public void implicitLeftJoin07()
-    {
+        testOp("(leftjoin (bgp (?x ?p ?o)(?x <http://pred> ?y)) (bgp (?x ?p1 ?o1)) ((= ?y ?x)))",
+               t_implicitLeftJoin,
+               "(leftjoin (bgp (?x ?p ?o)(?x <http://pred> ?y)) (assign ((?x ?y)) (bgp (?y ?p1 ?o1))))");
+    }
+
+    @Test public void implicitLeftJoin07() {
         // Possible to optimize some cases where it's an implicit left join
-        
+
         // Covers the case of both variables on both sides
         testOp(
-             "(leftjoin (bgp (?x ?p ?o)(?x <http://pred> ?y)) (bgp (?x <http://type> ?type)(?y ?p1 ?o1)) ((= ?x ?y)))",
-             t_implicitLeftJoin,
-             "(leftjoin (bgp (?x ?p ?o)(?x <http://pred> ?y)) (assign ((?x ?y)) (bgp (?y <http://type> ?type)(?y ?p1 ?o1))))");
-        
+               "(leftjoin (bgp (?x ?p ?o)(?x <http://pred> ?y)) (bgp (?x <http://type> ?type)(?y ?p1 ?o1)) ((= ?x ?y)))",
+               t_implicitLeftJoin,
+            "(leftjoin (bgp (?x ?p ?o)(?x <http://pred> ?y)) (assign ((?x ?y)) (bgp (?y <http://type> ?type)(?y ?p1 ?o1))))");
+
         // Swapping the order of the equality expression will make a difference in this case
         testOp(
-                "(leftjoin (bgp (?x ?p ?o)(?x <http://pred> ?y)) (bgp (?x <http://type> ?type)(?y ?p1 ?o1)) ((= ?y ?x)))",
-                t_implicitLeftJoin,
-                "(leftjoin (bgp (?x ?p ?o)(?x <http://pred> ?y)) (assign ((?y ?x)) (bgp (?x <http://type> ?type)(?x ?p1 ?o1))))");
-    }
-    
-    @Test public void implicitLeftJoin08()
-    {
+               "(leftjoin (bgp (?x ?p ?o)(?x <http://pred> ?y)) (bgp (?x <http://type> ?type)(?y ?p1 ?o1)) ((= ?y ?x)))",
+               t_implicitLeftJoin,
+               "(leftjoin (bgp (?x ?p ?o)(?x <http://pred> ?y)) (assign ((?y ?x)) (bgp (?x <http://type> ?type)(?x ?p1 ?o1))))");
+    }
+
+    @Test public void implicitLeftJoin08() {
         // We don't currently optimize the case where the filter will evaluate to false
         // for all solutions because neither variable in on the RHS
         testOp(
-             "(leftjoin (bgp (?x ?p ?o)(?x <http://pred> ?y)) (bgp (?a ?b ?c)) ((= ?x ?y)))",
-             t_implicitLeftJoin,
-             (String[])null);
-    }
-        
-    @Test public void implicitLeftJoin09()
-    {
+               "(leftjoin (bgp (?x ?p ?o)(?x <http://pred> ?y)) (bgp (?a ?b ?c)) ((= ?x ?y)))",
+               t_implicitLeftJoin,
+               (String[])null);
+    }
+
+    @Test public void implicitLeftJoin09() {
         // && means both conditions must hold so can optimize out the implicit join
         testOp(
-             "(leftjoin (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1)) (&& (= ?x ?y) (> ?o1 ?o2)))",
-             t_implicitLeftJoin,
-             "(leftjoin (bgp (?x ?p ?o)) (assign ((?y ?x)) (bgp (?x ?p1 ?o1))) (> ?o1 ?o2))");
-        
-        testOp(
-                "(leftjoin (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1)) (&& (> ?o1 ?o2) (= ?x ?y)))",
-                t_implicitLeftJoin,
-                "(leftjoin (bgp (?x ?p ?o)) (assign ((?y ?x)) (bgp (?x ?p1 ?o1))) (> ?o1 ?o2))");
-    }
-    
-    @Test public void implicitLeftJoin10()
-    {
+               "(leftjoin (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1)) (&& (= ?x ?y) (> ?o1 ?o2)))",
+               t_implicitLeftJoin,
+               "(leftjoin (bgp (?x ?p ?o)) (assign ((?y ?x)) (bgp (?x ?p1 ?o1))) (> ?o1 ?o2))");
+
+        testOp(
+               "(leftjoin (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1)) (&& (> ?o1 ?o2) (= ?x ?y)))",
+               t_implicitLeftJoin,
+               "(leftjoin (bgp (?x ?p ?o)) (assign ((?y ?x)) (bgp (?x ?p1 ?o1))) (> ?o1 ?o2))");
+    }
+
+    @Test public void implicitLeftJoin10() {
         // Unsafe to optimize
         testOp(
-             "(leftjoin (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1)) (|| (= ?x ?y) (> ?o1 ?o2)))",
-             t_implicitLeftJoin,
-             (String[])null);
-    }
-    
-    @Test public void implicitLeftJoin11()
-    {
+               "(leftjoin (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1)) (|| (= ?x ?y) (> ?o1 ?o2)))",
+               t_implicitLeftJoin,
+               (String[])null);
+    }
+
+    @Test public void implicitLeftJoin11() {
         // Unsafe to optimize because cannot guarantee that substituted variable is fixed on RHS
         testOp(
-             "(leftjoin (bgp (?x ?p ?o)) (leftjoin (bgp (?y ?p1 ?o1)) (bgp (?x ?p3 ?y))) (= ?x ?y))",
-             t_implicitLeftJoin,
-             (String[])null);
-        
+               "(leftjoin (bgp (?x ?p ?o)) (leftjoin (bgp (?y ?p1 ?o1)) (bgp (?x ?p3 ?y))) (= ?x ?y))",
+               t_implicitLeftJoin,
+               (String[])null);
+
         // Swapping the order of equality expressions should still leave it unsafe
         testOp(
-                "(leftjoin (bgp (?x ?p ?o)) (leftjoin (bgp (?y ?p1 ?o1)) (bgp (?x ?p3 ?y))) (= ?y ?x))",
-                t_implicitLeftJoin,
-                (String[])null);
-    }
-    
-    @Test public void implicitLeftJoin12()
-    {
+               "(leftjoin (bgp (?x ?p ?o)) (leftjoin (bgp (?y ?p1 ?o1)) (bgp (?x ?p3 ?y))) (= ?y ?x))",
+               t_implicitLeftJoin,
+               (String[])null);
+    }
+
+    @Test public void implicitLeftJoin12() {
         // Unlike implicit join overlapping conditions can be safely optimized since the left join
         // optimizer is smart enough to apply the optimizations in an appropriate order
         testOp(
-             "(leftjoin (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1) (?y ?p2 ?z)) ((= ?x ?y) (= ?x ?z)))",
-             t_implicitLeftJoin,
-             "(leftjoin (bgp (?x ?p ?o)) (assign ((?y ?x) (?z ?x)) (bgp (?x ?p1 ?o1) (?x ?p2 ?x))))");
-        
-        testOp(
-                "(leftjoin (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1) (?y ?p2 ?z)) ((= ?y ?x) (= ?x ?z)))",
-                t_implicitLeftJoin,
-                "(leftjoin (bgp (?x ?p ?o)) (assign ((?y ?x) (?z ?x)) (bgp (?x ?p1 ?o1) (?x ?p2 ?x))))");
-        
-        testOp(
-                "(leftjoin (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1) (?y ?p2 ?z)) ((= ?x ?y) (= ?z ?x)))",
-                t_implicitLeftJoin,
-                "(leftjoin (bgp (?x ?p ?o)) (assign ((?y ?x) (?z ?x)) (bgp (?x ?p1 ?o1) (?x ?p2 ?x))))");
-    }
-    
-    @Test public void implicitLeftJoin13()
-    {
+               "(leftjoin (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1) (?y ?p2 ?z)) ((= ?x ?y) (= ?x ?z)))",
+               t_implicitLeftJoin,
+               "(leftjoin (bgp (?x ?p ?o)) (assign ((?y ?x) (?z ?x)) (bgp (?x ?p1 ?o1) (?x ?p2 ?x))))");
+
+        testOp(
+               "(leftjoin (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1) (?y ?p2 ?z)) ((= ?y ?x) (= ?x ?z)))",
+               t_implicitLeftJoin,
+               "(leftjoin (bgp (?x ?p ?o)) (assign ((?y ?x) (?z ?x)) (bgp (?x ?p1 ?o1) (?x ?p2 ?x))))");
+
+        testOp(
+               "(leftjoin (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1) (?y ?p2 ?z)) ((= ?x ?y) (= ?z ?x)))",
+               t_implicitLeftJoin,
+            "(leftjoin (bgp (?x ?p ?o)) (assign ((?y ?x) (?z ?x)) (bgp (?x ?p1 ?o1) (?x ?p2 ?x))))");
+    }
+
+    @Test public void implicitLeftJoin13() {
         // There are some overlapping conditions that are safe to optimize however they may end up introducing
         // additional unnecessary assign operators
         testOp(
-                "(leftjoin (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1) (?y ?p2 ?z)) ((= ?x ?y) (= ?x ?z) (= ?y ?z)))",
-                t_implicitLeftJoin,
-                "(leftjoin (bgp (?x ?p ?o)) (assign ((?y ?z)) (assign ((?y ?x) (?z ?x)) (bgp (?x ?p1 ?o1) (?x ?p2 ?x)))))");
-        
-        testOp(
-                "(leftjoin (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1) (?y ?p2 ?z)) ((= ?z ?y) (= ?x ?z) (= ?x ?y)))",
-                t_implicitLeftJoin,
-                "(leftjoin (bgp (?x ?p ?o)) (assign ((?z ?x) (?y ?x)) (assign ((?z ?x)) (bgp (?x ?p1 ?o1) (?x ?p2 ?x)))))");
-        
-        testOp(
-                "(leftjoin (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1) (?y ?p2 ?z)) ((= ?z ?y) (= ?z ?x) (= ?y ?x)))",
-                t_implicitLeftJoin,
-                "(leftjoin (bgp (?x ?p ?o)) (assign ((?z ?x) (?y ?x)) (assign ((?z ?x)) (bgp (?x ?p1 ?o1) (?x ?p2 ?x)))))");
-    }
-    
-    @Test public void implicitLeftJoin14()
-    {
+               "(leftjoin (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1) (?y ?p2 ?z)) ((= ?x ?y) (= ?x ?z) (= ?y ?z)))",
+               t_implicitLeftJoin,
+               "(leftjoin (bgp (?x ?p ?o)) (assign ((?y ?z)) (assign ((?y ?x) (?z ?x)) (bgp (?x ?p1 ?o1) (?x ?p2 ?x)))))");
+
+        testOp(
+               "(leftjoin (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1) (?y ?p2 ?z)) ((= ?z ?y) (= ?x ?z) (= ?x ?y)))",
+               t_implicitLeftJoin,
+               "(leftjoin (bgp (?x ?p ?o)) (assign ((?z ?x) (?y ?x)) (assign ((?z ?x)) (bgp (?x ?p1 ?o1) (?x ?p2 ?x)))))");
+
+        testOp(
+               "(leftjoin (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1) (?y ?p2 ?z)) ((= ?z ?y) (= ?z ?x) (= ?y ?x)))",
+               t_implicitLeftJoin,
+               "(leftjoin (bgp (?x ?p ?o)) (assign ((?z ?x) (?y ?x)) (assign ((?z ?x)) (bgp (?x ?p1 ?o1) (?x ?p2 ?x)))))");
+    }
+
+    @Test public void implicitLeftJoin14() {
         // The optimizer is capable of eliminating the && entirely where appropriate
         testOp(
-                "(leftjoin (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1) (?y ?p2 ?z)) ((&& (= ?x ?y) (= ?x ?z))))",
-                t_implicitLeftJoin,
-                "(leftjoin (bgp (?x ?p ?o)) (assign ((?y ?x) (?z ?x)) (bgp (?x ?p1 ?o1) (?x ?p2 ?x))))");
-    }
-    
-    @Test public void implicitLeftJoin15()
-    {
+               "(leftjoin (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1) (?y ?p2 ?z)) ((&& (= ?x ?y) (= ?x ?z))))",
+               t_implicitLeftJoin,
+               "(leftjoin (bgp (?x ?p ?o)) (assign ((?y ?x) (?z ?x)) (bgp (?x ?p1 ?o1) (?x ?p2 ?x))))");
+    }
+
+    @Test public void implicitLeftJoin15() {
         // The optimizer is capable of going any depth into nested && to find conditions to apply since it uses ExprList.splitConjunction()
         testOp(
-                "(leftjoin (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1) (?y ?p2 ?z)) ((&& (&& (= ?x ?y) (> ?o1 10)) (= ?x ?z))))",
-                t_implicitLeftJoin,
-                "(leftjoin (bgp (?x ?p ?o)) (assign ((?y ?x) (?z ?x)) (bgp (?x ?p1 ?o1) (?x ?p2 ?x))) (> ?o1 10))");
-        
-        testOp(
-                "(leftjoin (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1) (?y ?p2 ?z)) ((&& (&& (> ?o1 10) (= ?x ?y)) (= ?x ?z))))",
-                t_implicitLeftJoin,
-                "(leftjoin (bgp (?x ?p ?o)) (assign ((?y ?x) (?z ?x)) (bgp (?x ?p1 ?o1) (?x ?p2 ?x))) (> ?o1 10))");
-    }
-    
-    @Test public void implicitLeftJoin16()
-    {
+               "(leftjoin (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1) (?y ?p2 ?z)) ((&& (&& (= ?x ?y) (> ?o1 10)) (= ?x ?z))))",
+               t_implicitLeftJoin,
+               "(leftjoin (bgp (?x ?p ?o)) (assign ((?y ?x) (?z ?x)) (bgp (?x ?p1 ?o1) (?x ?p2 ?x))) (> ?o1 10))");
+
+        testOp(
+               "(leftjoin (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1) (?y ?p2 ?z)) ((&& (&& (> ?o1 10) (= ?x ?y)) (= ?x ?z))))",
+               t_implicitLeftJoin,
+               "(leftjoin (bgp (?x ?p ?o)) (assign ((?y ?x) (?z ?x)) (bgp (?x ?p1 ?o1) (?x ?p2 ?x))) (> ?o1 10))");
+    }
+
+    @Test public void implicitLeftJoin16() {
         // The optimizer is capable of going any depth into nested && to find conditions to apply since it uses ExprList.splitConjunction()
         testOp(
-             "(leftjoin (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1) (?y ?p2 ?z)) ((&& (&& (< ?o1 20) (&& (= ?x ?y) (> ?o1 10))) (= ?x ?z))))",
-             t_implicitLeftJoin,
-             "(leftjoin (bgp (?x ?p ?o)) (assign ((?y ?x) (?z ?x)) (bgp (?x ?p1 ?o1) (?x ?p2 ?x))) ((< ?o1 20) (> ?o1 10)))");
-    }
-    
-    @Test public void implicitLeftJoin17()
-    {
+               "(leftjoin (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1) (?y ?p2 ?z)) ((&& (&& (< ?o1 20) (&& (= ?x ?y) (> ?o1 10))) (= ?x ?z))))",
+               t_implicitLeftJoin,
+               "(leftjoin (bgp (?x ?p ?o)) (assign ((?y ?x) (?z ?x)) (bgp (?x ?p1 ?o1) (?x ?p2 ?x))) ((< ?o1 20) (> ?o1 10)))");
+    }
+
+    @Test public void implicitLeftJoin17() {
         // The optimizer is capable of going any depth into nested && to find conditions to apply since it uses ExprList.splitConjunction()
         testOp(
-             "(leftjoin (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1) (?y ?p2 ?z)) ((&& (&& (= ?x ?y) (> ?o1 10)) (< ?o1 20))))",
-             t_implicitLeftJoin,
-             "(leftjoin (bgp (?x ?p ?o)) (assign ((?y ?x)) (bgp (?x ?p1 ?o1) (?x ?p2 ?z))) ((> ?o1 10) (< ?o1 20)))");
-    }
-    
-    @Test public void implicitLeftJoin18()
-    {
+               "(leftjoin (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1) (?y ?p2 ?z)) ((&& (&& (= ?x ?y) (> ?o1 10)) (< ?o1 20))))",
+               t_implicitLeftJoin,
+               "(leftjoin (bgp (?x ?p ?o)) (assign ((?y ?x)) (bgp (?x ?p1 ?o1) (?x ?p2 ?z))) ((> ?o1 10) (< ?o1 20)))");
+    }
+
+    @Test public void implicitLeftJoin18() {
         // The optimizer is capable of going any depth into nested && to find conditions to apply since it uses ExprList.splitConjunction()
         testOp(
-             "(leftjoin (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1) (?y ?p2 ?z)) ((&& (&& (= ?x ?y) (= ?y ?z)) (= ?x ?z))))",
-             t_implicitLeftJoin,
-             "(leftjoin (bgp (?x ?p ?o)) (assign ((?y ?x) (?z ?x)) (assign ((?y ?x)) (bgp (?x ?p1 ?o1) (?x ?p2 ?x)))))");
-    }
-    
-    @Test public void implicitLeftJoin19()
-    {
+               "(leftjoin (bgp (?x ?p ?o)) (bgp (?y ?p1 ?o1) (?y ?p2 ?z)) ((&& (&& (= ?x ?y) (= ?y ?z)) (= ?x ?z))))",
+               t_implicitLeftJoin,
+               "(leftjoin (bgp (?x ?p ?o)) (assign ((?y ?x) (?z ?x)) (assign ((?y ?x)) (bgp (?x ?p1 ?o1) (?x ?p2 ?x)))))");
+    }
+
+    @Test public void implicitLeftJoin19() {
         // Covers the case of both variables on left and neither on right
         testOp(
-             "(leftjoin (bgp (?x ?p ?o)(?x <http://pred> ?y)) (table unit) ((= ?x ?y)))",
-             t_implicitLeftJoin,
-             (String[])null);
-        
+               "(leftjoin (bgp (?x ?p ?o)(?x <http://pred> ?y)) (table unit) ((= ?x ?y)))",
+               t_implicitLeftJoin,
+               (String[])null);
+
         // Swapping the order of the equality expression should make no difference
         testOp(
-             "(leftjoin (bgp (?x ?p ?o)(?x <http://pred> ?y)) (table unit) ((= ?y ?x)))",
-             t_implicitLeftJoin,
-             (String[])null);
-    }
-    
-    @Test public void implicitLeftJoin20()
-    {
+               "(leftjoin (bgp (?x ?p ?o)(?x <http://pred> ?y)) (table unit) ((= ?y ?x)))",
+               t_implicitLeftJoin,
+               (String[])null);
+    }
+
+    @Test public void implicitLeftJoin20() {
         // Covers the case of one variable on left and neither on right
         testOp(
-             "(leftjoin (bgp (?x ?p ?o)) (table unit) ((= ?x ?y)))",
-             t_implicitLeftJoin,
-             (String[])null);
-        
+               "(leftjoin (bgp (?x ?p ?o)) (table unit) ((= ?x ?y)))",
+               t_implicitLeftJoin,
+               (String[])null);
+
         // Swapping the order of the equality expression should make no difference
         testOp(
-             "(leftjoin (bgp (?x ?p ?o)) (table unit) ((= ?y ?x)))",
-             t_implicitLeftJoin,
-             (String[])null);
-    }
-    
-    @Test public void implicitLeftJoin21()
-    {
+               "(leftjoin (bgp (?x ?p ?o)) (table unit) ((= ?y ?x)))",
+               t_implicitLeftJoin,
+               (String[])null);
+    }
+
+    @Test public void implicitLeftJoin21() {
         // Covers the case of one variable on left and neither on right
         testOp(
-             "(leftjoin (bgp (?y ?p ?o)) (table unit) ((= ?x ?y)))",
-             t_implicitLeftJoin,
-             (String[])null);
-        
+               "(leftjoin (bgp (?y ?p ?o)) (table unit) ((= ?x ?y)))",
+               t_implicitLeftJoin,
+               (String[])null);
+
         // Swapping the order of the equality expression should make no difference
         testOp(
-             "(leftjoin (bgp (?y ?p ?o)) (table unit) ((= ?y ?x)))",
-             t_implicitLeftJoin,
-             (String[])null);
-    }
-    
-    @Test public void implicitLeftJoin22()
-    {
+               "(leftjoin (bgp (?y ?p ?o)) (table unit) ((= ?y ?x)))",
+               t_implicitLeftJoin,
+               (String[])null);
+    }
+
+    @Test public void implicitLeftJoin22() {
         // Covers the case of no variables actually being relevant
         testOp(
-             "(leftjoin (bgp (?s ?p ?o)) (table unit) ((= ?x ?y)))",
-             t_implicitLeftJoin,
-             (String[])null);
-        
+               "(leftjoin (bgp (?s ?p ?o)) (table unit) ((= ?x ?y)))",
+               t_implicitLeftJoin,
+               (String[])null);
+
         // Swapping the order of the equality expression should make no difference
         testOp(
-             "(leftjoin (bgp (?s ?p ?o)) (table unit) ((= ?y ?x)))",
-             t_implicitLeftJoin,
-             (String[])null);
-    }
-    
-    @Test public void implicitLeftJoin23()
-    {
+               "(leftjoin (bgp (?s ?p ?o)) (table unit) ((= ?y ?x)))",
+               t_implicitLeftJoin,
+               (String[])null);
+    }
+
+    @Test public void implicitLeftJoin23() {
         // Covers the case of neither variable on left and both on right
         testOp(
-             "(leftjoin (table unit) (bgp (?x ?p ?o)(?x <http://pred> ?y)) ((= ?x ?y)))",
-             t_implicitLeftJoin,
-             "(leftjoin (table unit) (assign ((?x ?y)) (bgp (?y ?p ?o)(?y <http://pred> ?y))))");
-        
+               "(leftjoin (table unit) (bgp (?x ?p ?o)(?x <http://pred> ?y)) ((= ?x ?y)))",
+               t_implicitLeftJoin,
+               "(leftjoin (table unit) (assign ((?x ?y)) (bgp (?y ?p ?o)(?y <http://pred> ?y))))");
+
         // Swapping the order of the equality will make a difference in this case
         testOp(
-             "(leftjoin (table unit) (bgp (?x ?p ?o)(?x <http://pred> ?y)) ((= ?y ?x)))",
-             t_implicitLeftJoin,
-             "(leftjoin (table unit) (assign ((?y ?x)) (bgp (?x ?p ?o)(?x <http://pred> ?x))))");
-    }
-    
-    @Test public void implicitLeftJoin24()
-    {
-    	// Modified test case from JENA-692
-    	// Implicit join should not apply to the whole union because the variables involved aren't fixed
-    	testOp(
-			"(leftjoin (bgp (triple ?a <http://type> ?type)) (union (bgp (triple ?a :p :o1)) (bgp (triple ?b :p ?a))) ((= ?a ?b)))", 
-			t_implicitLeftJoin,
-			(String[])null);
-    }
-    
-    @Test public void implicitLeftJoinConditional01()
-    {
+               "(leftjoin (table unit) (bgp (?x ?p ?o)(?x <http://pred> ?y)) ((= ?y ?x)))",
+               t_implicitLeftJoin,
+               "(leftjoin (table unit) (assign ((?y ?x)) (bgp (?x ?p ?o)(?x <http://pred> ?x))))");
+    }
+
+    @Test public void implicitLeftJoin24() {
+        // Modified test case from JENA-692
+        // Implicit join should not apply to the whole union because the variables involved aren't fixed
+        testOp(
+               "(leftjoin (bgp (triple ?a <http://type> ?type)) (union (bgp (triple ?a :p :o1)) (bgp (triple ?b :p ?a))) ((= ?a ?b)))", 
+               t_implicitLeftJoin,
+               (String[])null);
+    }
+
+    @Test public void implicitLeftJoinConditional01() {
         // Can be optimized because not all assigns block linearization
         testOp(
-             "(leftjoin (bgp (?x ?p ?o)) (assign ((?y ?x)) (bgp (?x ?p1 ?o1))))",
-             new TransformJoinStrategy(),
-             "(conditional (bgp (?x ?p ?o)) (assign ((?y ?x)) (bgp (?x ?p1 ?o1))))");
-    }
-    
-    @Test public void inequality01()
-    {
+               "(leftjoin (bgp (?x ?p ?o)) (assign ((?y ?x)) (bgp (?x ?p1 ?o1))))",
+               new TransformJoinStrategy(),
+               "(conditional (bgp (?x ?p ?o)) (assign ((?y ?x)) (bgp (?x ?p1 ?o1))))");
+    }
+
+    @Test public void inequality01() {
         testOp("(filter (!= ?x <x>) (bgp ( ?s ?p ?x)) )",
-             t_inequality,
-             "(minus (bgp ( ?s ?p ?x)) (table (vars ?x) (row [?x <x>])))") ;
+               t_inequality,
+               "(minus (bgp ( ?s ?p ?x)) (table (vars ?x) (row [?x <x>])))") ;
     }
-    
-    @Test public void inequality02()
-    {
+
+    @Test public void inequality02() {
         // Not safe on strings
         testOp("(filter (!= ?x 'x') (bgp ( ?s ?p ?x)) )",
-             t_inequality,
-             (String[])null) ;
+               t_inequality,
+               (String[])null) ;
     }
 
-    @Test public void inequality03()
-    {
+    @Test public void inequality03() {
         // Not safe on numbers
         testOp("(filter (!= ?x 123) (bgp ( ?s ?p ?x)) )",
-             t_inequality,
-             (String[])null) ;
+               t_inequality,
+               (String[])null) ;
     }
-    
-    @Test public void inequality04()
-    {
+
+    @Test public void inequality04() {
         // Unused
         testOp("(filter (!= ?UNUSED <x>) (bgp ( ?s ?p ?x)) )",
-             t_inequality,
-             "(table empty)") ;
+               t_inequality,
+               "(table empty)") ;
     }
-    
-    @Test public void inequality05()
-    {
+
+    @Test public void inequality05() {
         // Can't optimize if filter does not cover vars in LHS 
         testOp("(filter (!= ?x2 <x>) (conditional (bgp ( ?s1 ?p1 ?x1))  (bgp ( ?s2 ?p2 ?x2))))",
-             t_equality,
-             (String[])null) ;
+               t_equality,
+               (String[])null) ;
     }
-    
-    @Test public void inequality06()
-    {
+
+    @Test public void inequality06() {
         testOp("(filter (!= ?x <x>) (conditional (bgp ( ?s ?p ?x))  (bgp ( ?s ?p ?x))))",
-             t_inequality,
-             "(minus (conditional (bgp ( ?s ?p ?x))  (bgp ( ?s ?p ?x))) (table (vars ?x) (row [?x <x>])))") ;
+               t_inequality,
+               "(minus (conditional (bgp ( ?s ?p ?x))  (bgp ( ?s ?p ?x))) (table (vars ?x) (row [?x <x>])))") ;
     }
-    
-    @Test public void inequality07()
-    {
+
+    @Test public void inequality07() {
         testOp("(filter (!= ?x <x>) (conditional (bgp ( ?s ?p ?x))  (bgp ( ?s ?p ?x1))))",
-             t_inequality,
-             "(minus (conditional (bgp ( ?s ?p ?x))  (bgp ( ?s ?p ?x1))) (table (vars ?x) (row [?x <x>])))") ;
+               t_inequality,
+               "(minus (conditional (bgp ( ?s ?p ?x))  (bgp ( ?s ?p ?x1))) (table (vars ?x) (row [?x <x>])))") ;
     }
-    
-    @Test public void inequality08()
-    {
+
+    @Test public void inequality08() {
         // Tests use of multiple != conditions on same variable
         testOp("(filter ((!= ?x <x>) (!= ?x <y>)) (bgp ( ?s ?p ?x)) )",
-             t_inequality,
-             "(minus (bgp (?s ?p ?x)) (table (vars ?p ?x) (row [?x <y>]) (row [?x <x>])))") ;
+               t_inequality,
+               "(minus (bgp (?s ?p ?x)) (table (vars ?p ?x) (row [?x <y>]) (row [?x <x>])))") ;
     }
-    
-    @Test public void inequality09()
-    {
+
+    @Test public void inequality09() {
         // Tests use of multiple != conditions on different variables
         testOp("(filter ((!= ?x <x>) (!= ?p <y>)) (bgp ( ?s ?p ?x)) )",
-             t_inequality,
-             "(minus (bgp (?s ?p ?x)) (table (vars ?p ?x) (row [?p <y>]) (row [?x <x>])))") ;
+               t_inequality,
+               "(minus (bgp (?s ?p ?x)) (table (vars ?p ?x) (row [?p <y>]) (row [?x <x>])))") ;
     }
-    
-    @Test public void inequality10()
-    {
+
+    @Test public void inequality10() {
         // Tests use of multiple != conditions on both same and different variables
         testOp("(filter ((!= ?x <x>) (!= ?x <y>) (!= ?p <type>)) (bgp ( ?s ?p ?x)) )",
-             t_inequality,
-             "(minus (bgp (?s ?p ?x)) (table (vars ?p ?x) (row [?p <type>]) (row [?x <y>]) (row [?x <x>])))") ;
+               t_inequality,
+               "(minus (bgp (?s ?p ?x)) (table (vars ?p ?x) (row [?p <type>]) (row [?x <y>]) (row [?x <x>])))") ;
     }
-    
-    @Test public void inequality11()
-    {
+
+    @Test public void inequality11() {
         // Other filter conditions should be preserved
         testOp("(filter ((!= ?x <x>) (> ?x 10)) (bgp ( ?s ?p ?x)) )",
-             t_inequality,
-             "(filter (> ?x 10) (minus (bgp ( ?s ?p ?x)) (table (vars ?x) (row [?x <x>]))))") ;
+               t_inequality,
+               "(filter (> ?x 10) (minus (bgp ( ?s ?p ?x)) (table (vars ?x) (row [?x <x>]))))") ;
     }
 }



Mime
View raw message