test/org/apache/pig/test/TestNewPlanRule.java - pig - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package org.apache.pig.test;

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotSame;
 import static org.junit.Assert.assertTrue;

 import java.util.List;

 import org.apache.pig.impl.logicalLayer.FrontendException;
 import org.apache.pig.newplan.BaseOperatorPlan;
 import org.apache.pig.newplan.Operator;
 import org.apache.pig.newplan.OperatorPlan;
 import org.apache.pig.newplan.PlanVisitor;
 import org.apache.pig.newplan.optimizer.Rule;
 import org.apache.pig.newplan.optimizer.Transformer;
 import org.junit.Before;
 import org.junit.Test;

 public class TestNewPlanRule {

     private static class SillyRule extends Rule {

         public SillyRule(String n, OperatorPlan p) {
             super(n, p);
         }

         @Override
         public Transformer getNewTransformer() {
             return null;
         }

         @Override
         protected OperatorPlan buildPattern() {
             // TODO Auto-generated method stub
             return null;
         }

     }

     private static class SillyPlan extends BaseOperatorPlan {

         SillyPlan() {
             super();
         }

         @Override
         public boolean isEqual(OperatorPlan other) {
             return false;
         }

     }

     private static class OP extends Operator {
         OP(String n, OperatorPlan p) {
             super(n, p);
         }

         public void accept(PlanVisitor v) {

         }

         @Override
         public boolean isEqual(Operator operator) {
             return false;
         }
     }

     private static class OP_Load extends OP {
         OP_Load(String n, OperatorPlan p) {
             super(n, p);
         }
     }

     private static class OP_Filter extends OP {
         OP_Filter(String n, OperatorPlan p) {
             super(n, p);
         }
     }

     private static class OP_Split extends OP {
         OP_Split(String n, OperatorPlan p) {
             super(n, p);
         }
     }

     private static class OP_Store extends OP {
         OP_Store(String n, OperatorPlan p) {
             super(n, p);
         }
     }

     private static class OP_Join extends OP {
         OP_Join(String n, OperatorPlan p) {
             super(n, p);
         }
     }


     OperatorPlan plan = null;
     Operator join;

     @Before
     public void setUp() {
         plan = new SillyPlan();
         Operator l1 = new OP_Load("p1", plan);
         plan.add(l1);
         Operator l2 = new OP_Load("p2", plan);
         plan.add(l2);
         Operator j1 = new OP_Join("j1", plan);
         plan.add(j1);
         Operator f1 = new OP_Filter("f1", plan);
         plan.add(f1);
         Operator f2 = new OP_Filter("f2", plan);
         plan.add(f2);
         Operator t1 = new OP_Split("t1",plan);
         plan.add(t1);
         Operator f3 = new OP_Filter("f3", plan);
         plan.add(f3);
         Operator f4 = new OP_Filter("f4", plan);
         plan.add(f4);
         Operator s1 = new OP_Store("s1", plan);
         plan.add(s1);
         Operator s2 = new OP_Store("s2", plan);
         plan.add(s2);

         // load --|-join - filter - filter - split |- filter - store
         // load --|                                |- filter - store
         plan.connect(l1, j1);
         plan.connect(l2, j1);
         plan.connect(j1, f1);
         plan.connect(f1, f2);
         plan.connect(f2, t1);
         plan.connect(t1, f3);
         plan.connect(t1, f4);
         plan.connect(f3, s1);
         plan.connect(f4, s2);

         join = j1;
     }

     @Test
     public void testMultiNode() throws Exception {
         //         load --|-join - filter - filter - split |- filter - store
         //         load --|
         // load -- filter-|
         Operator l3 = new OP_Load("p3", plan);
         Operator f5 = new OP_Filter("f5", plan);
         plan.add(l3);
         plan.add(f5);
         plan.connect(l3, f5);

          plan.connect(f5, join);


          OperatorPlan pattern = new SillyPlan();
          Operator op1 = new OP_Load("mmm1", pattern);
          Operator op2 = new OP_Filter("mmm2", pattern);
          Operator op3 = new OP_Join("mmm3", pattern);
          pattern.add(op1);
          pattern.add(op2);
          pattern.add(op3);
          pattern.connect(op1, op3);
          pattern.connect(op2, op3);

          Rule r = new SillyRule("basic", pattern);
          List<OperatorPlan> l = r.match(plan);
          assertEquals(1, l.size());
          OperatorPlan match = l.get(0);
          assertEquals(3, match.size());
          assertEquals(1, match.getSinks().size());
          assertEquals(join, match.getSinks().get(0));

          assertEquals(2, match.getSources().size());
          assertTrue(match.getSources().get(0).getClass().equals(OP_Load.class) || match.getSources().get(0).equals(f5) );
          assertTrue(match.getSources().get(1).getClass().equals(OP_Load.class) || match.getSources().get(1).equals(f5) );
          assertNotSame(match.getSources().get(0), match.getSources().get(1));
     }

     @Test
     public void testSingleNodeMatch() throws FrontendException {
         // search for Load
         OperatorPlan pattern = new SillyPlan();
         pattern.add(new OP_Load("mmm", pattern));

         Rule r = new SillyRule("basic", pattern);
         List<OperatorPlan> l = r.match(plan);
         assertEquals(2, l.size());

         Operator m1 = l.get(0).getSources().get(0);
         assertTrue(m1.getName().equals("p1") || m1.getName().equals("p2"));
         assertEquals(1, l.get(0).size());

         Operator m2 = l.get(1).getSources().get(0);
         assertTrue(m2.getName().equals("p1") || m2.getName().equals("p2"));
         assertEquals(1, l.get(1).size());
         assertNotSame(m1.getName(), m2.getName());

         // search for filter
         pattern = new SillyPlan();
         pattern.add(new OP_Filter("mmm",pattern));
         r = new SillyRule("basic", pattern);
         l = r.match(plan);
         assertEquals(4, l.size());

         m1 = l.get(0).getSources().get(0);
         assertTrue(m1.getName().equals("f1") || m1.getName().equals("f2")
                 || m1.getName().equals("f3") || m1.getName().equals("f4"));
         assertEquals(1, l.get(0).size());

         m2 = l.get(1).getSources().get(0);
         assertTrue(m1.getName().equals("f1") || m1.getName().equals("f2")
                 || m1.getName().equals("f3") || m1.getName().equals("f4"));
         assertEquals(1, l.get(1).size());
         assertNotSame(m1.getName(), m2.getName());

         // search for store
         pattern = new SillyPlan();
         pattern.add(new OP_Store("mmm",pattern));
         r = new SillyRule("basic", pattern);
         l = r.match(plan);
         assertEquals(l.size(), 2);

         m1 = l.get(0).getSources().get(0);
         assertTrue(m1.getName().equals("s1") || m1.getName().equals("s2"));
         assertEquals(l.get(0).size(), 1);

         m2 = l.get(1).getSources().get(0);
         assertTrue(m2.getName().equals("s1") || m2.getName().equals("s2"));
         assertEquals(l.get(1).size(), 1);
         assertNotSame(m1.getName(), m2.getName());

         // search for split
         pattern = new SillyPlan();
         pattern.add(new OP_Split("mmm",pattern));
         r = new SillyRule("basic", pattern);
         l = r.match(plan);
         assertEquals(l.size(), 1);

         m1 = l.get(0).getSources().get(0);
         assertTrue(m1.getName().equals("t1"));
         assertEquals(l.get(0).size(), 1);

         // search for join
         pattern = new SillyPlan();
         pattern.add(new OP_Join("mmm",pattern));
         r = new SillyRule("basic", pattern);
         l = r.match(plan);
         assertEquals(l.size(), 1);

         m1 = l.get(0).getSources().get(0);
         assertTrue(m1.getName().equals("j1"));
         assertEquals(l.get(0).size(), 1);

     }

     @Test
     public void testTwoNodeMatch() throws FrontendException {
         // search for 2 Loads at the same time
         OperatorPlan pattern = new SillyPlan();
         pattern.add(new OP_Load("mmm1", pattern));
         pattern.add(new OP_Load("mmm2", pattern));

         Rule r = new SillyRule("basic", pattern);
         List<OperatorPlan> l = r.match(plan);
         assertEquals(l.size(), 1);

         assertEquals(l.get(0).getSources().size(), 2);
         assertEquals(l.get(0).getSinks().size(), 2);
         assertEquals(l.get(0).size(), 2);

         Operator m1 = l.get(0).getSources().get(0);
         assertTrue(m1.getName().equals("p1") || m1.getName().equals("p2"));
         Operator m2 = l.get(0).getSources().get(1);
         assertTrue(m2.getName().equals("p1") || m2.getName().equals("p2"));
         assertNotSame(m1.getName(), m2.getName());


         // search for join then filter
         pattern = new SillyPlan();
         Operator s1 = new OP_Join("mmm1", pattern);
         Operator s2 = new OP_Filter("mmm2", pattern);
         pattern.add(s1);
         pattern.add(s2);
         pattern.connect(s1, s2);

         r = new SillyRule("basic", pattern);
         l = r.match(plan);
         assertEquals(1, l.size());

         assertEquals(1, l.get(0).getSources().size());
         assertEquals(1, l.get(0).getSinks().size());
         assertEquals(2, l.get(0).size());

         m1 = l.get(0).getSources().get(0);
         assertTrue(m1.getName().equals("j1"));
         m2 = l.get(0).getSinks().get(0);
         assertTrue(m2.getName().equals("f1"));


         // search for filter, then store
         pattern = new SillyPlan();
         s1 = new OP_Filter("mmm1", pattern);
         s2 = new OP_Store("mmm2", pattern);
         pattern.add(s1);
         pattern.add(s2);
         pattern.connect(s1, s2);

         r = new SillyRule("basic", pattern);
         l = r.match(plan);
         assertEquals(2, l.size());

         assertEquals(1, l.get(0).getSources().size());
         assertEquals(1, l.get(0).getSinks().size());

         // search for 2 loads, then join
         pattern = new SillyPlan();
         s1 = new OP_Load("mmm1", pattern);
         s2 = new OP_Load("mmm2", pattern);
         Operator s3 = new OP_Join("jjj", pattern);
         pattern.add(s1);
         pattern.add(s2);
         pattern.add(s3);
         pattern.connect(s1, s3);
         pattern.connect(s2, s3);

         r = new SillyRule("basic", pattern);
         l = r.match(plan);
         assertEquals(l.size(), 1);

         // search for split then 2 filters
         pattern = new SillyPlan();
         s1 = new OP_Split("mmm1", pattern);
         s2 = new OP_Filter("mmm2", pattern);
         s3 = new OP_Filter("mmm3", pattern);
         pattern.add(s1);
         pattern.add(s2);
         pattern.add(s3);
         pattern.connect(s1, s2);
         pattern.connect(s1, s3);

         r = new SillyRule("basic", pattern);
         l = r.match(plan);
         assertEquals(1, l.size());

         assertEquals(1, l.get(0).getSources().size());
         assertEquals(2, l.get(0).getSinks().size());
         assertEquals(3, l.get(0).size());

         m1 = l.get(0).getSources().get(0);
         assertEquals("t1", m1.getName());
         m2 = l.get(0).getSinks().get(0);
         assertTrue(m2.getName().equals("f3") || m2.getName().equals("f4"));
         m2 = l.get(0).getSinks().get(1);
         assertTrue(m2.getName().equals("f3") || m2.getName().equals("f4"));
     }

     @Test
     public void testThreeNodeMatch() throws FrontendException {
         // load --|                                |- filter - store
         // load --|-join - filter - filter - split |- filter - store
         //               | filter - store
         //               | filter - store
         Operator f5 = new OP_Filter("f5", plan);
         Operator f6 = new OP_Filter("f6", plan);
         Operator s5 = new OP_Store("s5", plan);
         Operator s6 = new OP_Store("s6", plan);
         plan.add(f5);
         plan.add(f6);
         plan.add(s5);
         plan.add(s6);
         plan.connect(f5, s5);
         plan.connect(f6, s6);
         plan.connect(join, f5);
         plan.connect(join, f6);

         OperatorPlan pattern = new SillyPlan();
         Operator s1 = new OP_Join("mmm1", pattern);
         Operator s2 = new OP_Filter("mmm2", pattern);
         Operator s3 = new OP_Filter("mmm3", pattern);
         Operator s4 = new OP_Filter("mmm4", pattern);
         pattern.add(s1);
         pattern.add(s2);
         pattern.add(s3);
         pattern.add(s4);
         pattern.connect(s1, s2);
         pattern.connect(s1, s3);
         pattern.connect(s1, s4);

         Rule r = new SillyRule("basic", pattern);
         List<OperatorPlan> l = r.match(plan);
         assertEquals(1, l.size());

         assertEquals(1, l.get(0).getSources().size());
         assertEquals(3, l.get(0).getSinks().size());
         assertEquals(4, l.get(0).size());

         Operator m1,m2;
         m1 = l.get(0).getSources().get(0);
         assertEquals("j1", m1.getName());
         for( int i=0; i < 3; i++ ) {
           m2 = l.get(0).getSinks().get(i);
           assertTrue(m2.getName().equals("f1")
                    || m2.getName().equals("f5")
                    || m2.getName().equals("f6")
           );
         }
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package org.apache.pig.test;

	import static org.junit.Assert.assertEquals;
	import static org.junit.Assert.assertNotSame;
	import static org.junit.Assert.assertTrue;

	import java.util.List;

	import org.apache.pig.impl.logicalLayer.FrontendException;
	import org.apache.pig.newplan.BaseOperatorPlan;
	import org.apache.pig.newplan.Operator;
	import org.apache.pig.newplan.OperatorPlan;
	import org.apache.pig.newplan.PlanVisitor;
	import org.apache.pig.newplan.optimizer.Rule;
	import org.apache.pig.newplan.optimizer.Transformer;
	import org.junit.Before;
	import org.junit.Test;

	public class TestNewPlanRule {

	private static class SillyRule extends Rule {

	public SillyRule(String n, OperatorPlan p) {
	super(n, p);
	}

	@Override
	public Transformer getNewTransformer() {
	return null;
	}

	@Override
	protected OperatorPlan buildPattern() {
	// TODO Auto-generated method stub
	return null;
	}

	}

	private static class SillyPlan extends BaseOperatorPlan {

	SillyPlan() {
	super();
	}

	@Override
	public boolean isEqual(OperatorPlan other) {
	return false;
	}

	}

	private static class OP extends Operator {
	OP(String n, OperatorPlan p) {
	super(n, p);
	}

	public void accept(PlanVisitor v) {

	}

	@Override
	public boolean isEqual(Operator operator) {
	return false;
	}
	}

	private static class OP_Load extends OP {
	OP_Load(String n, OperatorPlan p) {
	super(n, p);
	}
	}

	private static class OP_Filter extends OP {
	OP_Filter(String n, OperatorPlan p) {
	super(n, p);
	}
	}

	private static class OP_Split extends OP {
	OP_Split(String n, OperatorPlan p) {
	super(n, p);
	}
	}

	private static class OP_Store extends OP {
	OP_Store(String n, OperatorPlan p) {
	super(n, p);
	}
	}

	private static class OP_Join extends OP {
	OP_Join(String n, OperatorPlan p) {
	super(n, p);
	}
	}


	OperatorPlan plan = null;
	Operator join;

	@Before
	public void setUp() {
	plan = new SillyPlan();
	Operator l1 = new OP_Load("p1", plan);
	plan.add(l1);
	Operator l2 = new OP_Load("p2", plan);
	plan.add(l2);
	Operator j1 = new OP_Join("j1", plan);
	plan.add(j1);
	Operator f1 = new OP_Filter("f1", plan);
	plan.add(f1);
	Operator f2 = new OP_Filter("f2", plan);
	plan.add(f2);
	Operator t1 = new OP_Split("t1",plan);
	plan.add(t1);
	Operator f3 = new OP_Filter("f3", plan);
	plan.add(f3);
	Operator f4 = new OP_Filter("f4", plan);
	plan.add(f4);
	Operator s1 = new OP_Store("s1", plan);
	plan.add(s1);
	Operator s2 = new OP_Store("s2", plan);
	plan.add(s2);

	// load --\|-join - filter - filter - split \|- filter - store
	// load --\| \|- filter - store
	plan.connect(l1, j1);
	plan.connect(l2, j1);
	plan.connect(j1, f1);
	plan.connect(f1, f2);
	plan.connect(f2, t1);
	plan.connect(t1, f3);
	plan.connect(t1, f4);
	plan.connect(f3, s1);
	plan.connect(f4, s2);

	join = j1;
	}

	@Test
	public void testMultiNode() throws Exception {
	// load --\|-join - filter - filter - split \|- filter - store
	// load --\|
	// load -- filter-\|
	Operator l3 = new OP_Load("p3", plan);
	Operator f5 = new OP_Filter("f5", plan);
	plan.add(l3);
	plan.add(f5);
	plan.connect(l3, f5);

	plan.connect(f5, join);


	OperatorPlan pattern = new SillyPlan();
	Operator op1 = new OP_Load("mmm1", pattern);
	Operator op2 = new OP_Filter("mmm2", pattern);
	Operator op3 = new OP_Join("mmm3", pattern);
	pattern.add(op1);
	pattern.add(op2);
	pattern.add(op3);
	pattern.connect(op1, op3);
	pattern.connect(op2, op3);

	Rule r = new SillyRule("basic", pattern);
	List<OperatorPlan> l = r.match(plan);
	assertEquals(1, l.size());
	OperatorPlan match = l.get(0);
	assertEquals(3, match.size());
	assertEquals(1, match.getSinks().size());
	assertEquals(join, match.getSinks().get(0));

	assertEquals(2, match.getSources().size());
	assertTrue(match.getSources().get(0).getClass().equals(OP_Load.class) \|\| match.getSources().get(0).equals(f5) );
	assertTrue(match.getSources().get(1).getClass().equals(OP_Load.class) \|\| match.getSources().get(1).equals(f5) );
	assertNotSame(match.getSources().get(0), match.getSources().get(1));
	}

	@Test
	public void testSingleNodeMatch() throws FrontendException {
	// search for Load
	OperatorPlan pattern = new SillyPlan();
	pattern.add(new OP_Load("mmm", pattern));

	Rule r = new SillyRule("basic", pattern);
	List<OperatorPlan> l = r.match(plan);
	assertEquals(2, l.size());

	Operator m1 = l.get(0).getSources().get(0);
	assertTrue(m1.getName().equals("p1") \|\| m1.getName().equals("p2"));
	assertEquals(1, l.get(0).size());

	Operator m2 = l.get(1).getSources().get(0);
	assertTrue(m2.getName().equals("p1") \|\| m2.getName().equals("p2"));
	assertEquals(1, l.get(1).size());
	assertNotSame(m1.getName(), m2.getName());

	// search for filter
	pattern = new SillyPlan();
	pattern.add(new OP_Filter("mmm",pattern));
	r = new SillyRule("basic", pattern);
	l = r.match(plan);
	assertEquals(4, l.size());

	m1 = l.get(0).getSources().get(0);
	assertTrue(m1.getName().equals("f1") \|\| m1.getName().equals("f2")
	\|\| m1.getName().equals("f3") \|\| m1.getName().equals("f4"));
	assertEquals(1, l.get(0).size());

	m2 = l.get(1).getSources().get(0);
	assertTrue(m1.getName().equals("f1") \|\| m1.getName().equals("f2")
	\|\| m1.getName().equals("f3") \|\| m1.getName().equals("f4"));
	assertEquals(1, l.get(1).size());
	assertNotSame(m1.getName(), m2.getName());

	// search for store
	pattern = new SillyPlan();
	pattern.add(new OP_Store("mmm",pattern));
	r = new SillyRule("basic", pattern);
	l = r.match(plan);
	assertEquals(l.size(), 2);

	m1 = l.get(0).getSources().get(0);
	assertTrue(m1.getName().equals("s1") \|\| m1.getName().equals("s2"));
	assertEquals(l.get(0).size(), 1);

	m2 = l.get(1).getSources().get(0);
	assertTrue(m2.getName().equals("s1") \|\| m2.getName().equals("s2"));
	assertEquals(l.get(1).size(), 1);
	assertNotSame(m1.getName(), m2.getName());

	// search for split
	pattern = new SillyPlan();
	pattern.add(new OP_Split("mmm",pattern));
	r = new SillyRule("basic", pattern);
	l = r.match(plan);
	assertEquals(l.size(), 1);

	m1 = l.get(0).getSources().get(0);
	assertTrue(m1.getName().equals("t1"));
	assertEquals(l.get(0).size(), 1);

	// search for join
	pattern = new SillyPlan();
	pattern.add(new OP_Join("mmm",pattern));
	r = new SillyRule("basic", pattern);
	l = r.match(plan);
	assertEquals(l.size(), 1);

	m1 = l.get(0).getSources().get(0);
	assertTrue(m1.getName().equals("j1"));
	assertEquals(l.get(0).size(), 1);

	}

	@Test
	public void testTwoNodeMatch() throws FrontendException {
	// search for 2 Loads at the same time
	OperatorPlan pattern = new SillyPlan();
	pattern.add(new OP_Load("mmm1", pattern));
	pattern.add(new OP_Load("mmm2", pattern));

	Rule r = new SillyRule("basic", pattern);
	List<OperatorPlan> l = r.match(plan);
	assertEquals(l.size(), 1);

	assertEquals(l.get(0).getSources().size(), 2);
	assertEquals(l.get(0).getSinks().size(), 2);
	assertEquals(l.get(0).size(), 2);

	Operator m1 = l.get(0).getSources().get(0);
	assertTrue(m1.getName().equals("p1") \|\| m1.getName().equals("p2"));
	Operator m2 = l.get(0).getSources().get(1);
	assertTrue(m2.getName().equals("p1") \|\| m2.getName().equals("p2"));
	assertNotSame(m1.getName(), m2.getName());


	// search for join then filter
	pattern = new SillyPlan();
	Operator s1 = new OP_Join("mmm1", pattern);
	Operator s2 = new OP_Filter("mmm2", pattern);
	pattern.add(s1);
	pattern.add(s2);
	pattern.connect(s1, s2);

	r = new SillyRule("basic", pattern);
	l = r.match(plan);
	assertEquals(1, l.size());

	assertEquals(1, l.get(0).getSources().size());
	assertEquals(1, l.get(0).getSinks().size());
	assertEquals(2, l.get(0).size());

	m1 = l.get(0).getSources().get(0);
	assertTrue(m1.getName().equals("j1"));
	m2 = l.get(0).getSinks().get(0);
	assertTrue(m2.getName().equals("f1"));


	// search for filter, then store
	pattern = new SillyPlan();
	s1 = new OP_Filter("mmm1", pattern);
	s2 = new OP_Store("mmm2", pattern);
	pattern.add(s1);
	pattern.add(s2);
	pattern.connect(s1, s2);

	r = new SillyRule("basic", pattern);
	l = r.match(plan);
	assertEquals(2, l.size());

	assertEquals(1, l.get(0).getSources().size());
	assertEquals(1, l.get(0).getSinks().size());

	// search for 2 loads, then join
	pattern = new SillyPlan();
	s1 = new OP_Load("mmm1", pattern);
	s2 = new OP_Load("mmm2", pattern);
	Operator s3 = new OP_Join("jjj", pattern);
	pattern.add(s1);
	pattern.add(s2);
	pattern.add(s3);
	pattern.connect(s1, s3);
	pattern.connect(s2, s3);

	r = new SillyRule("basic", pattern);
	l = r.match(plan);
	assertEquals(l.size(), 1);

	// search for split then 2 filters
	pattern = new SillyPlan();
	s1 = new OP_Split("mmm1", pattern);
	s2 = new OP_Filter("mmm2", pattern);
	s3 = new OP_Filter("mmm3", pattern);
	pattern.add(s1);
	pattern.add(s2);
	pattern.add(s3);
	pattern.connect(s1, s2);
	pattern.connect(s1, s3);

	r = new SillyRule("basic", pattern);
	l = r.match(plan);
	assertEquals(1, l.size());

	assertEquals(1, l.get(0).getSources().size());
	assertEquals(2, l.get(0).getSinks().size());
	assertEquals(3, l.get(0).size());

	m1 = l.get(0).getSources().get(0);
	assertEquals("t1", m1.getName());
	m2 = l.get(0).getSinks().get(0);
	assertTrue(m2.getName().equals("f3") \|\| m2.getName().equals("f4"));
	m2 = l.get(0).getSinks().get(1);
	assertTrue(m2.getName().equals("f3") \|\| m2.getName().equals("f4"));
	}

	@Test
	public void testThreeNodeMatch() throws FrontendException {
	// load --\| \|- filter - store
	// load --\|-join - filter - filter - split \|- filter - store
	// \| filter - store
	// \| filter - store
	Operator f5 = new OP_Filter("f5", plan);
	Operator f6 = new OP_Filter("f6", plan);
	Operator s5 = new OP_Store("s5", plan);
	Operator s6 = new OP_Store("s6", plan);
	plan.add(f5);
	plan.add(f6);
	plan.add(s5);
	plan.add(s6);
	plan.connect(f5, s5);
	plan.connect(f6, s6);
	plan.connect(join, f5);
	plan.connect(join, f6);

	OperatorPlan pattern = new SillyPlan();
	Operator s1 = new OP_Join("mmm1", pattern);
	Operator s2 = new OP_Filter("mmm2", pattern);
	Operator s3 = new OP_Filter("mmm3", pattern);
	Operator s4 = new OP_Filter("mmm4", pattern);
	pattern.add(s1);
	pattern.add(s2);
	pattern.add(s3);
	pattern.add(s4);
	pattern.connect(s1, s2);
	pattern.connect(s1, s3);
	pattern.connect(s1, s4);

	Rule r = new SillyRule("basic", pattern);
	List<OperatorPlan> l = r.match(plan);
	assertEquals(1, l.size());

	assertEquals(1, l.get(0).getSources().size());
	assertEquals(3, l.get(0).getSinks().size());
	assertEquals(4, l.get(0).size());

	Operator m1,m2;
	m1 = l.get(0).getSources().get(0);
	assertEquals("j1", m1.getName());
	for( int i=0; i < 3; i++ ) {
	m2 = l.get(0).getSinks().get(i);
	assertTrue(m2.getName().equals("f1")
	\|\| m2.getName().equals("f5")
	\|\| m2.getName().equals("f6")
	);
	}
	}
	}