package sequentialLogic;

import junit.framework.TestCase;

/**
 * A JUnit test case class for the sequentialLogic package.
 */

public class CircuitTest extends TestCase
{
  /**
   * Test InTerminal
   */
  public void test01a() 
  {
    sequentialLogic.Circuit circuit = new sequentialLogic.Circuit("test01a");
    
    circuit.addNode("in01", "inTerminal");
    circuit.setValue("in01", true);
    
    assert( circuit.getValue("in01") );
  }
  
  /**
   * Test OutTerminal
   */
  public void test01b() 
  {
    sequentialLogic.Circuit circuit = new sequentialLogic.Circuit("test01b");
    
    circuit.addNode("out01", "outTerminal");
    circuit.setValue("out01", true);
   
    assert( circuit.getValue("out01") );
  }
  
  /**
   * Test 0-input AndGate
   */
  public void test01c() 
  {
    sequentialLogic.Circuit circuit = new sequentialLogic.Circuit("test01c");
    
    circuit.addNode("and01", "and");
    circuit.setValue("and01", true);
    
    assert( circuit.getValue("and01") );
  }
  
  /**
   * Test 0-input OrGate
   */
  public void test01d() 
  {
    sequentialLogic.Circuit circuit = new sequentialLogic.Circuit("test01d");
    
    circuit.addNode("or01", "or");
    circuit.setValue("or01", true);
    
    assert( circuit.getValue("or01") );
  }
  
  /**
   * Test Invertor
   */
  public void test01e() 
  {
    sequentialLogic.Circuit circuit = new sequentialLogic.Circuit("test01e");
    
    circuit.addNode("invertor01", "invertor");
    circuit.setValue("invertor01", true);
    
    assert( circuit.getValue("invertor01") );
  }

  /**
   * Test FlipFlop
   */
  public void test01f() 
  {
    sequentialLogic.Circuit circuit = new sequentialLogic.Circuit("test01f");
    
    circuit.addNode("FF01", "FF");
    circuit.setValue("FF01", true);
    
    assert( circuit.getValue("FF01") );
  }

  /**
   * Test connection from inTerminal to and
   */
  public void test01g() 
  {
    sequentialLogic.Circuit circuit = new sequentialLogic.Circuit("test01g");
    
    circuit.addNode("in01",  "inTerminal");
    circuit.addNode("and01", "and");
    circuit.connect("in01",  "and01");
    
    circuit.setValue("in01", true);
    circuit.update("and01");
   
    assert( circuit.getValue("and01") );
  }
 
  /**
   * Test connection from an or to outTerminal
   */
  public void test01h() 
  {
    sequentialLogic.Circuit circuit = new sequentialLogic.Circuit("test01h");
    
    circuit.addNode("or01", "or");
    circuit.addNode("out01", "outTerminal");
    
    circuit.connect("or01", "out01");
    
    circuit.setValue("or01", true);
    circuit.update("out01");
   
    assert( circuit.getValue("out01") );
  }
  
  /**
   * Test invertor truth table
   */
  public void test01i() 
  {
    sequentialLogic.Circuit circuit = new sequentialLogic.Circuit("test01i");
    
    circuit.addNode("in01", "inTerminal");
    circuit.addNode("inv01", "invertor");
    circuit.addNode("out01", "outTerminal");
    
    circuit.connect("in01", "inv01");
    circuit.connect("inv01", "out01");
   
    circuit.setValue("in01", false);
    circuit.update("inv01");
    circuit.update("out01");
   
    assert( circuit.getValue("out01") );

    circuit.setValue("in01", true);
    circuit.update("inv01");
    circuit.update("out01");
   
    assert( !circuit.getValue("out01") );
}
  
  /**
   * Test 2-ary and truth table
   */
  public void test01j() 
  {
    sequentialLogic.Circuit circuit = new sequentialLogic.Circuit("test01j");
    
    circuit.addNode("in01",  "inTerminal");
    circuit.addNode("in02",  "inTerminal");
    circuit.addNode("and01", "and");
    circuit.addNode("out01",  "outTerminal");
    
    circuit.connect("in01", "and01");
    circuit.connect("in02", "and01");
    circuit.connect("and01", "out01");
  
    circuit.setValue("in01", false);
    circuit.setValue("in02", false);
    circuit.update("and01");

    circuit.update("out01");
   
    assert( !circuit.getValue("out01") );

    circuit.setValue("in01", false);
    circuit.setValue("in02", true);
    circuit.update("and01");
    circuit.update("out01");
   
    assert( !circuit.getValue("out01") );

    circuit.setValue("in01", true);
    circuit.setValue("in02", false);
    circuit.update("and01");
    circuit.update("out01");
   
    assert( !circuit.getValue("out01") );

    circuit.setValue("in01", true);
    circuit.setValue("in02", true);
    circuit.update("and01");
    circuit.update("out01");
   
    assert( circuit.getValue("out01") );
  }  

  /**
   * Test 2-ary or truth table
   */
  public void test01k() 
  {
    sequentialLogic.Circuit circuit = new sequentialLogic.Circuit("test01k");
    
    circuit.addNode("in01",  "inTerminal");
    circuit.addNode("in02",  "inTerminal");
    circuit.addNode("or01", "or");
    circuit.addNode("out01",  "outTerminal");
    
    circuit.connect("in01", "or01");
    circuit.connect("in02", "or01");
    circuit.connect("or01", "out01");
  
    circuit.setValue("in01", false);
    circuit.setValue("in02", false);
    circuit.update("or01");

    circuit.update("out01");
   
    assert( !circuit.getValue("out01") );

    circuit.setValue("in01", false);
    circuit.setValue("in02", true);
    circuit.update("or01");
    circuit.update("out01");
   
    assert( circuit.getValue("out01") );

    circuit.setValue("in01", true);
    circuit.setValue("in02", false);
    circuit.update("or01");
    circuit.update("out01");
   
    assert( circuit.getValue("out01") );

    circuit.setValue("in01", true);
    circuit.setValue("in02", true);
    circuit.update("or01");
    circuit.update("out01");
   
    assert( circuit.getValue("out01") );
  }  

 /**
   * Test sequential circuit that remembers whether input was ever true
   */
  public void test01l() 
  {
    sequentialLogic.Circuit circuit = new sequentialLogic.Circuit("test01l");
    
    circuit.addNode("in01",  "inTerminal");
    circuit.addNode("or01", "or");
    circuit.addNode("FF01", "FF");
    circuit.addNode("out01",  "outTerminal");
    
    circuit.connect("in01", "or01");
    circuit.connect("or01", "FF01");
    circuit.connect("FF01", "or01");
    circuit.connect("FF01", "out01");
  
    circuit.setValue("in01", false);
    circuit.update("or01");
    circuit.update("FF01");
    circuit.update("out01");
    assert( !circuit.getValue("out01") );

    circuit.setValue("in01", false);
    circuit.update("or01");
    circuit.update("FF01");
    circuit.update("out01");
    assert( !circuit.getValue("out01") );

    circuit.setValue("in01", true);
    circuit.update("or01");
    circuit.update("FF01");
    circuit.update("out01");
    assert( circuit.getValue("out01") );

    circuit.setValue("in01", false);
    circuit.update("or01");
    circuit.update("FF01");
    circuit.update("out01");
    assert( circuit.getValue("out01") );
}  

 /**
   * Test sequential circuit that indicates parity
   * Note that we start using update() for the entire circuit
   * rather than for individual nodes.
   */
  public void test01m() 
  {
    sequentialLogic.Circuit circuit = new sequentialLogic.Circuit("test01m");
    
    circuit.addNode("in01",  "inTerminal");
    circuit.addNode("xor01", "xor");
    circuit.addNode("FF01",  "FF");
    circuit.addNode("out01", "outTerminal");
    
    circuit.connect("in01",  "xor01");
    circuit.connect("xor01", "FF01");
    circuit.connect("FF01",  "xor01");
    circuit.connect("FF01",  "out01");
  
    circuit.setValue("in01", false);
    circuit.update();
    assert( !circuit.getValue("out01") );

    circuit.setValue("in01", false);
    circuit.update();
    assert( !circuit.getValue("out01") );

    circuit.setValue("in01", true);
    circuit.update();
    assert( circuit.getValue("out01") );

    circuit.setValue("in01", true);
    circuit.update();
    assert( !circuit.getValue("out01") );
}  

  /**
   * Test sequential circuit that cycles 00-01-10-11 forever
   * with no input.
   */
  public void test01n() 
  {
    sequentialLogic.Circuit circuit = new sequentialLogic.Circuit("test01n");
    
    circuit.addNode("inv01", "invertor");
    circuit.addNode("xor01", "xor");
    circuit.addNode("FF01",  "FF");
    circuit.addNode("FF02",  "FF");
    circuit.addNode("out01", "outTerminal");
    circuit.addNode("out02", "outTerminal");
    
    circuit.connect("inv01", "FF02");
    circuit.connect("xor01", "FF01");
    circuit.connect("FF02",  "inv01");
    circuit.connect("FF02",  "xor01");
    circuit.connect("FF01",  "xor01");
    
    circuit.connect("FF01",  "out01");
    circuit.connect("FF02",  "out02");
  
    assert( !circuit.getValue("out01") && !circuit.getValue("out02"));

    circuit.update();
    assert( !circuit.getValue("out01") && circuit.getValue("out02"));
    
    circuit.update();
    assert( circuit.getValue("out01") && !circuit.getValue("out02"));

    circuit.update();
    assert( circuit.getValue("out01") && circuit.getValue("out02"));

    circuit.update();
    assert( !circuit.getValue("out01") && !circuit.getValue("out02"));

    circuit.update();
    assert( !circuit.getValue("out01") && circuit.getValue("out02"));
    
    circuit.update();
    assert( circuit.getValue("out01") && !circuit.getValue("out02"));

    circuit.update();
    assert( circuit.getValue("out01") && circuit.getValue("out02"));

    circuit.update();
    assert( !circuit.getValue("out01") && !circuit.getValue("out02"));
}  

  /**
   * Test shift register
   * This is an N-bit shift register, with an inTerminal for each bit.
   * When load = true, the flip-flops are set to the current inTerminal values.
   * Whenever the clock ticks, the current value of a flip-flop is shifted to
   * the next flip-flop (i to i+1).
   */
  public void test01o() 
  {
    sequentialLogic.Circuit circuit = new sequentialLogic.Circuit("test01o");
    
    // Number of flip-flops in this shift register
    int numFFs = 4;
    
    // Add InTerminals, FFs, OutTerminals in that order
    
    // The "load" terminal is raised to load the flip-flop from other inputs.
    
    circuit.addNode("load", "inTerminal");
    
    // Other InTerminals are for data
    
    for( int i = 0; i < numFFs; i++ )
    {
      circuit.addNode("data"+i, "inTerminal");
    }

    for( int i = 0; i < numFFs; i++ )
    {
      circuit.addNode("and"+i, "and");
    }

    for( int i = 1; i < numFFs; i++ )
    {
      circuit.addNode("or"+i, "or");
    }

    // Want to update later FFs first.
    // Fix in the next version.
    
    for( int i = numFFs-1; i >= 0; i-- )
    {
      circuit.addNode("FF"+i, "FF");
    }
   
    for( int i = 0; i < numFFs; i++ )
    {
      circuit.addNode("out"+i, "outTerminal");
    }

    circuit.connect("load", "and0");
    circuit.connect("data0", "and0");
    circuit.connect("and0", "FF0");

    for( int i = 1; i < numFFs; i++ )
    {
      circuit.connect("load",   "and"+i);
      circuit.connect("data"+i, "and"+i);
      circuit.connect("and"+i, "or"+i);
      circuit.connect("or"+i, "FF"+i);
    }

    for( int i = 1; i < numFFs; i++ )
    {
      circuit.connect("FF"+(i-1), "or"+i);
    }

    for( int i = 0; i < numFFs; i++ )
    {
      circuit.connect("FF"+i, "out"+i);
    }
    
    // Set to load bit into data0
    
    circuit.setValue("data0", true);
    for( int i = 1; i < numFFs; i++ )
    {
      circuit.setValue("data"+i, false);
    }
    
    circuit.setValue("load", true);
    circuit.update();
    
    assert( circuit.getValue("out0") &&
           !circuit.getValue("out1") &&
           !circuit.getValue("out2") &&
           !circuit.getValue("out3"));

    circuit.setValue("data0", false);
    circuit.setValue("load", false);
    circuit.update();
    assert(!circuit.getValue("out0") &&
            circuit.getValue("out1") &&
           !circuit.getValue("out2") &&
           !circuit.getValue("out3"));
 
    // Shift one position at each update

    circuit.update();
    assert(!circuit.getValue("out0") &&
           !circuit.getValue("out1") &&
            circuit.getValue("out2") &&
           !circuit.getValue("out3"));

    circuit.update();
    assert(!circuit.getValue("out0") &&
           !circuit.getValue("out1") &&
           !circuit.getValue("out2") &&
            circuit.getValue("out3"));

    // Until shifted off the end
    
    circuit.update();
    assert(!circuit.getValue("out0") &&
           !circuit.getValue("out1") &&
           !circuit.getValue("out2") &&
           !circuit.getValue("out3"));

    // Set to load bit into data3

    circuit.setValue("data3", true);
    circuit.setValue("load", true);
    circuit.update();
    assert(!circuit.getValue("out0") &&
           !circuit.getValue("out1") &&
           !circuit.getValue("out2") &&
            circuit.getValue("out3"));

    // Set to load bits into data0 and data2

    circuit.setValue("data0", true);
    circuit.setValue("data1", false);
    circuit.setValue("data2", true);
    circuit.setValue("data3", false);
    circuit.setValue("load", true);
     circuit.update();
    assert( circuit.getValue("out0") &&
           !circuit.getValue("out1") &&
            circuit.getValue("out2") &&
           !circuit.getValue("out3"));

    // Then shift those bits to 1 and 3

    circuit.setValue("load", false);
    circuit.update();
    assert(!circuit.getValue("out0") &&
            circuit.getValue("out1") &&
           !circuit.getValue("out2") &&
            circuit.getValue("out3"));
}

  /**
   * Test sequential adder
   * This circuit adds a sequence of pairs of bits, starting at the
   * least-significant. At each step, any carry bit is held in the FF
   * for the next step.
   */
  public void test01p()
  {
   sequentialLogic.Circuit circuit = new sequentialLogic.Circuit("test01p");

   circuit.addNode("in1", "inTerminal");
   circuit.addNode("in2", "inTerminal");
   circuit.addNode("xor1", "xor");
   circuit.addNode("and1", "and");
   circuit.addNode("and2", "and");
   circuit.addNode("and3", "and");
   circuit.addNode("or1", "or");
   circuit.addNode("FF1", "FF");
   circuit.addNode("out1", "outTerminal");


   circuit.connect("in1", "xor1");
   circuit.connect("in2", "xor1");
   circuit.connect("FF1", "xor1");

   circuit.connect("in1", "and1");
   circuit.connect("FF1", "and1");
   circuit.connect("in2", "and2");
   circuit.connect("FF1", "and2");
   circuit.connect("in1", "and3");
   circuit.connect("in2", "and3");
   circuit.connect("and1", "or1");
   circuit.connect("and2", "or1");
   circuit.connect("and3", "or1");

   circuit.connect("or1", "FF1");

   circuit.connect("xor1", "out1");

   circuit.setValue("in1", true);
   circuit.setValue("in2", false);
   circuit.update();
   assert(  !circuit.getValue("FF1")
          && circuit.getValue("out1"));

   circuit.setValue("in1", false);
   circuit.setValue("in2", true);
   circuit.update();
   assert(  !circuit.getValue("FF1")
          && circuit.getValue("out1"));

   circuit.setValue("in1", true);
   circuit.setValue("in2", true);
   circuit.update();
   assert(    circuit.getValue("FF1")
          && !circuit.getValue("out1"));


   circuit.setValue("in1", true);
   circuit.setValue("in2", false);
   circuit.update();
   assert(    circuit.getValue("FF1")
          && !circuit.getValue("out1"));

   circuit.setValue("in1", false);
   circuit.setValue("in2", true);
   circuit.update();
   assert(    circuit.getValue("FF1")
          && !circuit.getValue("out1"));

   circuit.setValue("in1", true);
   circuit.setValue("in2", true);
   circuit.update();
   assert(   circuit.getValue("FF1")
          && circuit.getValue("out1"));

   circuit.setValue("in1", false);
   circuit.setValue("in2", false);
   circuit.update();
   assert(  !circuit.getValue("FF1")
          && circuit.getValue("out1"));

   circuit.setValue("in1", false);
   circuit.setValue("in2", false);
   circuit.update();
   assert(   !circuit.getValue("FF1")
          && !circuit.getValue("out1"));
  }

}