// This class drives the FiniteStateMachine class and all dependent classes.
// It has been designed to test various features of the FSM code and
// the error checking built into it.  The output is a number of
// test cases, with descriptive text for each case, and the word
// "passed" or "failed" for each case.
// This code should be modified when any changes are added to the FSM
// so that those changes can be automatically tested.
public class Driver {
    int caseNumber = 0;    // Used to associated numbers with test cases
    String testCaseString; // Used to build up the string displaying a test case result


	public static void main(String argv[]) 
	{ 
		Driver myself = new Driver();
		myself.buildMachine(); 
		myself.foobarMachine();
	} // end main

	// print header for test case
	void newCase( String description )
	{
		caseNumber++;

		testCaseString = caseNumber + ".  " + description;
	} // end newCase

	// print result of test case
	void caseResult( String result )
	{
		// line up passed/failed statement on column 60 or later
		int len = testCaseString.length();

		if (len < 60)
		 for (int i = 0; i < (60 - len); i++)
    		 testCaseString += " ";

		testCaseString += result;

		System.out.println( testCaseString );    
		testCaseString = null;  // deliberately set to null so we catch
		 						// unbalanced use of the case formatting
								// routines 
	} // end caseResult

	// print result of test case, with amplifying info indented on next line
	void caseResult( String result, String ampInfo )
	{
		// line up passed/failed statement on column 60 or later
		int len = testCaseString.length();

		if (len < 60)
		  for (int i = 0; i < (60 - len); i++)
    		  testCaseString += " ";

		testCaseString += result;

		System.out.println( testCaseString );

		System.out.print("    ");
		System.out.println(ampInfo);
	} // end caseResult

	public void testMachine( FiniteStateMachine m,
                    	   String testString,
						   String expectedState ) 
	{
		// Given a machine m, and series of single-character events testString,
		// verify that the machine ends up in expectedState.
		// The expectedState of "exception" is special, and indicates an exception.
		int i;
		Exception ex=null;

		m.reset();
		String curstate=m.getCurrentState().getLabel();
		newCase("testing "+testString+": ");
		// each time through this loop we extract a character from the
		// string and feed it as an event to the state machine.  When
		// the loop is done, the state machine is excepted to be
		// in a particular state.
		for (i=0; i<testString.length(); i++) 
	    {
			String eventString=""+testString.charAt(i)+"";
			try {
				curstate= m.sendEvent(eventString);
			} 
			catch (Exception e) 
			{
				curstate="exception";
				ex=e;
				break;
			} // end try-catch block
			
		} // end for
		
		if (curstate == expectedState) 
		{
		    caseResult("passed");
		} 
		else if (curstate == "exception") 
		{
		    caseResult("failed", "exception " + ex);
		} 
		else 
		{
		  caseResult("failed", "expected state " + expectedState + ", got state " +curstate);
		} // end if-else if-else
		
	} // end method testMachine

	public void foobarMachine() 
	{
		// Builds a machine that accepts strings of the form (foo)*bar, and tests it.
		// okay is the final state
		FiniteStateMachine machine = new FiniteStateMachine();
		try {
			machine.addState("wants_f_or_b");
			machine.addState("wants_oo");
			machine.addState("wants_o");
			machine.addState("wants_ar");
			machine.addState("wants_r");
			machine.addState("okay");
			machine.addTransition("wants_f_or_b","wants_oo","f");
			machine.addTransition("wants_f_or_b","wants_ar","b");
			machine.addTransition("wants_oo","wants_o","o");
			machine.addTransition("wants_o","wants_f_or_b","o");
			machine.addTransition("wants_ar","wants_r","a");
			machine.addTransition("wants_r","okay","r");
			machine.setInitialState("wants_f_or_b");
			//machine.displayMe();
			machine.startSimulation();
			testMachine(machine,"foobar","okay");
			testMachine(machine,"foobarr","exception");
			testMachine(machine,"","wants_f_or_b");
			testMachine(machine,"f","wants_oo");
			testMachine(machine,"foofoobar","okay");
			testMachine(machine,"fobar","exception");
			testMachine(machine,"fooobar","exception");
			testMachine(machine,"fooba","wants_r");
			testMachine(machine,"bar","okay");
		} catch (Exception e) {
			System.out.println("Exception: "+e);
	} // end try-catch block
	} // end method foobarMachine

    // main test routine.  Sets up a FSM and checks basic exception
	// handling.
    public void buildMachine()
    {
		boolean exception_caught;
		String result;
		FiniteStateMachine machine = new FiniteStateMachine();

		/* build legitimate machine */
		result="passed";
		newCase("Trying to create states: ");
		try {
			machine.addState("state1");
			machine.addState("state2");
			machine.addState("state3");
			machine.addState("state4");
			machine.addState("state5");
			//machine.displayMe();
		} catch (Exception e) {
			System.out.println("Exception "+e);
			result="failed";
		} // end try-catch block
		caseResult(result);

		newCase("Trying to add transitions: ");
		// add states 1 to 5
		result="passed";
		try {
			machine.addTransition("state1","state2","x");
			machine.addTransition("state1","state1","a");
			machine.addTransition("state1","state3","b");
			machine.addTransition("state2","state4","a");
			machine.addTransition("state2","state3","c");
			machine.addTransition("state3","state2","c");
			machine.addTransition("state5","state4","c");
		} catch (Exception e) {
			System.out.println("Exception "+e);
			result="failed";
		} // end try-catch block
		caseResult(result);

		newCase("Test starting machine without initial state defined.");
		result="failed";
		try
		{
			machine.startSimulation();
			// should never get here: exception will be thrown
			machine.stopSimulation();
		}
		catch (Exception e)           { result="passed"; }
		caseResult(result);

		/* add link to nonexistent state */
		newCase("Testing add to nonexistant state: ");
		result="failed";
		try
		{
			machine.addTransition("state4","state7","c");
		}
		catch (StateDoesNotExistException e) { result="passed"; }
		catch (Exception e)                  
		{ 
			System.out.println("Exception "+e);
			result="failed"; 
		} // end try-catch block
		caseResult(result);

		/* add link from a state that already has different action for the event*/
		newCase("Testing adding duplicate transition: ");
		result="failed";
		try
		{
			machine.addTransition("state1","state5","x");
		}
		catch (DuplicateTransition e) { result="passed"; }
		catch (Exception e)           
		{ 
			System.out.println("Exception "+e);
			result="failed"; 
		} // end try-catch block
		caseResult(result);

		/* remove a state with links to and from it*/
		newCase("Removing state with links to and from it: ");
		result="failed";
		try
		{
			machine.removeState("state4");
		}
		catch (Exception e)           { result="passed"; }
		caseResult(result);


		newCase("Test setting start state to nonexistant state: ");
		result="failed";
		try
		{
			//set start set to non existant state
			machine.setInitialState("state9");
		}
		catch (Exception e)           { result="passed"; }
		caseResult(result);

		newCase("Trying to run machine now: ");
		result="passed";
		try
		{
			//set start set to 1
			machine.setInitialState("state1");
			machine.startSimulation();
		} catch (Exception e) { 
			System.out.println("Exception "+e);
			result="failed";
		} // end try-catch block
		caseResult(result);


		/* run machine and give it events*/
		//machine.displayMe();
		testMachine(machine, "aaxcccca","state4");
		newCase("xccccb");
		result="failed";
		try
		{
			machine.reset();
			machine.sendEvent("x");
			machine.sendEvent("c");
			machine.sendEvent("c");
			machine.sendEvent("c");
			machine.sendEvent("b");

		} catch (Exception e) { 
		    result="passed"; 
		} // end try-catch block
		caseResult(result);
	} // end method buildMachine
	
} // end class Driver