org.testtoolinterfaces.testresult.TestGroupResult Maven / Gradle / Ivy

Go to download
/**
 * 
 */
package org.testtoolinterfaces.testresult;

import java.util.ArrayList;
import java.util.Hashtable;
import java.util.Enumeration;

import org.testtoolinterfaces.testsuite.TestGroup;

import org.testtoolinterfaces.utils.Trace;

/**
 * @author Arjan Kranenburg
 *
 */
public class TestGroupResult extends TestResult implements TestGroupResultLinkObserver,
														   TestCaseResultLinkObserver,
														   TestStepResultObserver
{
    private TestGroup myTestGroup;
    private ResultTiming myTiming;

    private Hashtable myPrepareResults;
    private Hashtable myTestCaseResultLinks;
    private Hashtable myTestGroupResultLinks;
    private Hashtable myRestoreResults;
    
    private ArrayList myObserverCollection;

    /**
	 * @param aTestGroupName
	 */
	public TestGroupResult(TestGroup aTestGroup)
	{
		super();

	    Trace.println(Trace.CONSTRUCTOR, "TestGroupResult( " + aTestGroup + " )" );
	    myTestGroup = aTestGroup;

		myPrepareResults = new Hashtable();
		myTestCaseResultLinks = new Hashtable();
		myTestGroupResultLinks = new Hashtable();
		myRestoreResults = new Hashtable();
		
		myObserverCollection = new ArrayList();
	}

	/**
	 * @param aPrepareResult
	 */
	public void addInitialization(TestStepResult aPrepareResult)
	{
	    Trace.println(Trace.SETTER);
	    myPrepareResults.put( myPrepareResults.size(), aPrepareResult );
	    
	    aPrepareResult.register(this);

	    notifyObservers();
	}

	/**
	 * @param anInitializationResult
	 */
	public void addTestCase(TestCaseResultLink aTestCaseResultLink)
	{
	    Trace.println(Trace.SETTER);
	    myTestCaseResultLinks.put( myTestCaseResultLinks.size(), aTestCaseResultLink );
	    
	    aTestCaseResultLink.register(this);

	    notifyObservers();
	}

	public void addTestGroup(TestGroupResultLink aTestGroupResultLink)
	{
	    Trace.println(Trace.SETTER);
	    myTestGroupResultLinks.put( myTestGroupResultLinks.size(), aTestGroupResultLink );

	    aTestGroupResultLink.register(this);

	    notifyObservers();
	}

	/**
	 * @param anInitializationResult
	 */
	public void addRestore(TestStepResult aRestoreResult)
	{
	    Trace.println(Trace.SETTER);
	    myRestoreResults.put( myRestoreResults.size(), aRestoreResult );
	    
	    aRestoreResult.register(this);

	    notifyObservers();
	}

	@Override
	public void setExecutionPath(String anExecutionPath)
	{
		super.setExecutionPath(anExecutionPath);
		
	    for (TestStepResult result : myPrepareResults.values())
	    {
	    	result.setExecutionPath(anExecutionPath + "." + this.getId());
	    }

	    for (TestStepResult result : myRestoreResults.values())
	    {
	    	result.setExecutionPath(anExecutionPath + "." + this.getId());
	    }
	}

	/**
	 * @return the Test Group ID
	 */
	public String getId()
	{
	    Trace.println(Trace.GETTER);
		return myTestGroup.getId();
	}

	public String getDescription()
	{
	    Trace.println(Trace.GETTER);
		return myTestGroup.getDescription();
	}
	
	public ArrayList getRequirements()
	{
	    Trace.println(Trace.GETTER);
		return myTestGroup.getRequirements();
	}
	
	public Hashtable getPrepareResults()
	{
	    Trace.println(Trace.GETTER);
		return myPrepareResults;
	}
	
	public Hashtable getTestCaseResultLinks()
	{
	    Trace.println(Trace.GETTER);
		return myTestCaseResultLinks;
	}
	
	public Hashtable getTestGroupResultLinks()
	{
	    Trace.println(Trace.GETTER);
		return myTestGroupResultLinks;
	}
	
	public Hashtable getRestoreResults()
	{
	    Trace.println(Trace.GETTER);
		return myRestoreResults;
	}

	public void setResult(VERDICT aResult)
	{
		// NOP
	    
	    // notifyObservers();
	}
	
	/**
	 * @return VERDICT.UNKNOWN (Always)
	 * Note: There is no total verdict.
	 *       Use the getNrOf...() methods to get statistics of this Test Group.
	 */
	public VERDICT getResult()
	{
	    Trace.println(Trace.GETTER);
		return VERDICT.UNKNOWN;
	}

	/**
	 * @return the myTiming
	 */
	public ResultTiming getTiming()
	{
		return myTiming;
	}
	
	public ResultSummary getSummary()
	{
	    Trace.println(Trace.GETTER);

	    int nrOfTCsPassed = 0;
		int nrOfTCsFailed = 0;
		int nrOfTCsUnknown = 0;
		int nrOfTCsError = 0;

	    for (Enumeration keys = myTestCaseResultLinks.keys(); keys.hasMoreElements();)
	    {
	    	VERDICT verdict = myTestCaseResultLinks.get(keys.nextElement()).getResult();
	    	if ( verdict == VERDICT.PASSED )
	    	{
	    		nrOfTCsPassed += 1;
	    	}
	    	else if ( verdict == VERDICT.FAILED )
	    	{
	    		nrOfTCsFailed += 1;
	    	}
	    	else if ( verdict == VERDICT.UNKNOWN )
	    	{
	    		nrOfTCsUnknown += 1;
	    	}
	    	else if ( verdict == VERDICT.ERROR )
	    	{
	    		nrOfTCsError += 1;
	    	}
	    }
	    
	    for (Enumeration keys = myTestGroupResultLinks.keys(); keys.hasMoreElements();)
	    {
	    	ResultSummary summary = myTestGroupResultLinks.get(keys.nextElement()).getSummary();
    		nrOfTCsPassed += summary.getNrOfTCsPassed();
	    	nrOfTCsFailed += summary.getNrOfTCsFailed();
	    	nrOfTCsUnknown += summary.getNrOfTCsUnknown();
	    	nrOfTCsError += summary.getNrOfTCsError();
	    }

	    return new ResultSummary( nrOfTCsPassed, nrOfTCsFailed, nrOfTCsUnknown, nrOfTCsError );
	}
	
	// Implementation of the Observer Pattern
	
	protected void notifyObservers()
	{
	    Trace.println(Trace.EXEC_PLUS);

	    for (TestGroupResultObserver observer : myObserverCollection)
	    {
	    	observer.notify(this);
	    }
	}
	
	public void register( TestGroupResultObserver anObserver )
	{
	    Trace.println(Trace.SETTER);
	    myObserverCollection.add(anObserver);
	}

	public void unRegisterObserver( TestGroupResultObserver anObserver )
	{
	    Trace.println(Trace.SETTER);
	    myObserverCollection.remove( anObserver );
	}

	public void notify(TestGroupResultLink aTestGroupResultLink)
	{
	    Trace.println(Trace.EXEC_UTIL);
		notifyObservers();
	}

	public void notify(TestCaseResultLink aTestCaseResultLink)
	{
	    Trace.println(Trace.EXEC_UTIL);
		notifyObservers();
	}

	public void notify(TestStepResult aTestStepResult)
	{
	    Trace.println(Trace.EXEC_UTIL);
		notifyObservers();
	}
}