path: root/plugins/org.eclipse.osee.ote.core/src/org/eclipse/osee/ote/core/TestCase.java

/*******************************************************************************
 * Copyright (c) 2004, 2007 Boeing.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Boeing - initial API and implementation
 *******************************************************************************/
package org.eclipse.osee.ote.core;

import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.logging.Level;

import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;

import org.codehaus.jackson.annotate.JsonProperty;
import org.eclipse.osee.framework.jdk.core.persistence.Xmlizable;
import org.eclipse.osee.framework.jdk.core.persistence.XmlizableStream;
import org.eclipse.osee.framework.jdk.core.util.xml.Jaxp;
import org.eclipse.osee.framework.jdk.core.util.xml.XMLStreamWriterUtil;
import org.eclipse.osee.framework.logging.OseeLog;
import org.eclipse.osee.ote.core.enums.PromptResponseType;
import org.eclipse.osee.ote.core.environment.EnvironmentTask;
import org.eclipse.osee.ote.core.environment.TestEnvironment;
import org.eclipse.osee.ote.core.environment.interfaces.ICancelTimer;
import org.eclipse.osee.ote.core.environment.interfaces.IExecutionUnitManagement;
import org.eclipse.osee.ote.core.environment.interfaces.IScriptControl;
import org.eclipse.osee.ote.core.environment.interfaces.ITestEnvironmentAccessor;
import org.eclipse.osee.ote.core.environment.interfaces.ITestLogger;
import org.eclipse.osee.ote.core.environment.interfaces.ITestStation;
import org.eclipse.osee.ote.core.environment.interfaces.ITimeout;
import org.eclipse.osee.ote.core.environment.interfaces.ITimerControl;
import org.eclipse.osee.ote.core.log.record.RequirementRecord;
import org.eclipse.osee.ote.core.log.record.TestCaseRecord;
import org.eclipse.osee.ote.core.log.record.TestDescriptionRecord;
import org.eclipse.osee.ote.core.log.record.TestRecord;
import org.eclipse.ote.scheduler.Scheduler;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

/**
 * TestCase is the abstract base class for all test cases. This class provides the interfaces necessary for a TestCase
 * to be part of a {@link org.eclipse.osee.ote.core.TestScript TestScript}.
 * <p>
 * The TestCase class contains the following information:
 * <ul>
 * <li><b>Standalone</b> - This is used to determine if a TestCase can be used in a selective run list.
 * <ul>
 * <li><b>true</b> - The TestCase runs as expected regardless of order.
 * <li><b>false</b> - The TestCase must be run in a given order with other test cases to work as expected.
 * </ul>
 * <li><b>Test Case Number</b> - A serial number automatically assigned at the time of construction.
 * <li><b>Tracability</b> - The requirements that are tested by this TestCase.
 * </ul>
 * <p>
 * When building a new TestCase object it is important to remember that the object contains information describing the
 * test case in addition to the run time code. It is also important to understand that the when writing classes which
 * within a TestScript that the object must be instantiated (typically done in the constructor) with a reference to the
 * TestScript it is within or else it will not be executed.
 * <p>
 * The following sample should be followed closely when building TestCase objects. <br>
 * <br>
 * <code>
 * public class OipCase extends TestCase {
 * 		<ul style="list-style: none">
 * <li>		public OipCase(TestScript parent) {
 * 			<ul style="list-style: none">
 * <li>			</code><i>Use <b>one</b> of the following constructors based on if this TestCase is standalone</i><code>
 * <li>			super(parent);</code> <i>Standalone defaulted to <b>false</b></i><code>
 * <li>			super(parent, true);</code><i>Standalone explicitly set to <b>true</b></i><code>
 * <li>
 * <li>			</code><i>All requirements tested in the test case should be noted here with the </i>
 * <code>{@link org.eclipse.osee.ote.core.TestCase#addTracability(String) addTracability}</code><i> method.</i> <code>
 * 			</ul>
 * <li>		}
 * <li>
 * <li>		</code><i><b>Note:</b>It is very important that </i><code>doTestCase</code><i> always has the </i>
 * <code>throws InterrupedException</code><i> in the method declaration. The ability to abort a script relies on this
 * statement, and without it many calls would have to be wrapped with a try/catch block.</i><code>
 * <li>		public void doTestCase(ITestEnvironmentAccessor environment, ITestLogger logger) throws InterruptedException {
 * 			<ul style="list-style: none">
 * <li>			</code><i>Place all of the runtime code for the test case here.</i><code>
 * 			</ul>
 * <li>		}
 * 		</ul>
 * }
 * </code>
 * 
 * @see org.eclipse.osee.ote.core.TestScript
 * @author Ryan D. Brooks
 * @author Robert A. Fisher
 */
public abstract class TestCase implements ITestEnvironmentAccessor, Xmlizable, XmlizableStream {
   protected ITestLogger logger;
   private ITestEnvironmentAccessor environment;
   private final boolean standAlone;
   private final WeakReference<TestScript> testScript;
   private final TestDescriptionRecord testDescription;
   @JsonProperty
   public int number;
   protected List<RequirementRecord> traceability = new ArrayList<>();

   /**
    * TestCase Constructor.
    */
   public TestCase(TestScript testScript) {
      this(testScript, false);
   }

   /**
    * TestCase Constructor.
    */
   public TestCase(TestScript testScript, boolean standAlone) {
      this(testScript, standAlone, true);
   }

   /**
    * TestCase Constructor.
    */
   protected TestCase(TestScript testScript, boolean standAlone, boolean addToRunList) {
      super();
      this.testDescription = new TestDescriptionRecord(testScript.getTestEnvironment());
      this.standAlone = standAlone;
      if (addToRunList) {
         this.number = testScript.addTestCase(this);
      }
      this.testScript = new WeakReference<>(testScript);
      this.environment = testScript.getTestEnvironment();
      GCHelper.getGCHelper().addRefWatch(this);
   }
   
   protected void setEnv(ITestEnvironmentAccessor env){
      this.environment = env;
   }

   public TestCase(ITestEnvironmentAccessor accessor) {
      this.testDescription = new TestDescriptionRecord(accessor);

      // TODO we have two different traceability tags here.... we need to combine these or get rid
      // of them all together since define and the artifact framework specifies traceability
      // this.tracability = new ArrayList();
      this.traceability = new ArrayList<>();

      this.standAlone = false;
      ;
      this.number = 1;
      this.testScript = null;
      this.environment = accessor;

   }

   /**
    * Called by baseDoTestCase(). This is implemented by the tester's in each test case in the test script.
    * 
    * @param environment The Test environment.
    */
   public abstract void doTestCase(ITestEnvironmentAccessor environment, ITestLogger logger) throws InterruptedException;

   public Element getTastCaseNumberXml(Document doc) {
      return Jaxp.createElement(doc, "Number", String.valueOf(number));
   }

   public void writeTestCaseNumber(XMLStreamWriter writer) throws XMLStreamException {
      XMLStreamWriterUtil.writeElement(writer, "Number", String.valueOf(number));
   }

   public void writeTestCaseClassName(XMLStreamWriter writer) throws XMLStreamException {
      String name = getName();
      if (name == null || name.length() == 0) {
         name = "";
      }
      XMLStreamWriterUtil.writeElement(writer, "Name", name);
   }
   
   @JsonProperty
   public String getName() {
       return this.getClass().getSimpleName();
   }

   public void writeTracability(XMLStreamWriter writer) throws XMLStreamException {
      writer.writeStartElement("Tracability");
      for (RequirementRecord record : traceability) {
         record.toXml(writer);
      }
      writer.writeEndElement();
   }

   public Element getTestCaseClassName(Document doc) {
      String name = this.getClass().getName();
      if (name == null || name.length() == 0) {
         name = "";
      }
      return Jaxp.createElement(doc, "Name", name);
   }
   
   public String getTestCaseClassName() {
	   return this.getClass().getName();
   }

   public TestCase getTestCase() {
      return this;
   }

   /**
    * @return Returns the testCaseNumber.
    */
   public int getTestCaseNumber() {
      return number;
   }

   public ITestEnvironmentAccessor getTestEnvironment() {
      return environment;
   }

   public TestRecord getTestRecord() {
      return new TestCaseRecord(getTestEnvironment(), this);
   }

   /**
    * @return Returns the testScript.
    */
   @Override
   public TestScript getTestScript() {
      return testScript.get();
   }

   public Element getTracabilityXml(Document doc) {
      Element traceElement = doc.createElement("Tracability");
      for (RequirementRecord record : traceability) {
         traceElement.appendChild(record.toXml(doc));

      }
      return traceElement;
   }

   /**
    * @return Returns the standAlone.
    */
   public boolean isStandAlone() {
      return standAlone;
   }

   public void prompt() throws InterruptedException {
      getTestScript().prompt();
   }

   public void prompt(String message) throws InterruptedException {
      getTestScript().prompt(new TestPrompt(message, PromptResponseType.NONE));
   }

   public void promptPassFail(String message) throws InterruptedException {
      getTestScript().getLogger().methodCalled(getTestScript().getTestEnvironment(), new MethodFormatter().add(message));

      getTestScript().promptPassFail(message);

      getTestScript().getLogger().methodEnded(getTestScript().getTestEnvironment());
   }

   public void promptPause(String message) throws InterruptedException {
      getTestScript().promptPause(message);
   }

   public void promptStep(String message) throws InterruptedException {
      getTestScript().prompt(new TestPrompt(message, PromptResponseType.SCRIPT_STEP));
   }

   public String promptInput(String message) throws InterruptedException {
      return getTestScript().prompt(new TestPrompt(message, PromptResponseType.USER_INPUT));
   }

   /**
    * Logs the results of a test point.
    * 
    * @param passed boolean T/F
    * @param expected The expected information
    * @param actual The actual information
    */
   public void testpoint(boolean passed, String testPointName, String expected, String actual) {
      logger.testpoint(this.getTestEnvironment(), this.getTestScript(), this, passed, testPointName, expected, actual);
   }

   @Override
   public String toString() {
      String description = getTestScript().getClass().getName() + "Test Case " + number + ":";
      if (traceability != null) {
         for (RequirementRecord record : traceability) {
            description += "\n\t" + record;
         }
      }
      return description;
   }

   @Override
   public Element toXml(Document doc) {
      Element testCaseElement = doc.createElement("TestCase");
      testCaseElement.appendChild(getTastCaseNumberXml(doc));
      testCaseElement.appendChild(getTestCaseClassName(doc));
      testCaseElement.appendChild(getTracabilityXml(doc));
      return testCaseElement;
   }

   @Override
   public void toXml(XMLStreamWriter writer) throws XMLStreamException {
      writer.writeStartElement("TestCase");
      writeTestCaseNumber(writer);
      writeTestCaseClassName(writer);
      writeTracability(writer);
   }

   /**
    * Starts running the test case. Calls doTestCase(), which is implemented by the tester in each test case.
    * 
    * @param environment The Test Enviornment.
    */
   public void baseDoTestCase(ITestEnvironmentAccessor environment) throws InterruptedException {
      this.logger = environment.getLogger();

      logger.testCaseBegan(this); // This is required for valid outfile.
      //This creates the test case outfile logging.

      environment.getTestScript().setTestCase(this);
      OseeLog.logf(TestEnvironment.class, OteLevel.TEST_EVENT, "Starting Test Case %s.%s",
         this.getTestScript().getClass().getSimpleName(), getName());
      doTestCase(environment, environment.getLogger());
   }

   @Override
   public void abortTestScript() {
      environment.abortTestScript();
   }

   @Override
   public boolean addTask(EnvironmentTask task) {
      return environment.addTask(task);
   }

   @Override
   public void associateObject(Class<?> c, Object obj) {
      environment.associateObject(c, obj);
   }

   @Override
   public Object getAssociatedObject(Class<?> c) {
      return environment.getAssociatedObject(c);
   }

   @Override
   public Set<Class<?>> getAssociatedObjects() {
      return environment.getAssociatedObjects();
   }

   /*
    * public ITestEnvironmentCommandCallback getClientCallback() { return environment.getClientCallback(); }
    */

   // public EnvironmentType getEnvironmentType() {
   // return environment.getEnvironmentType();
   // }
   @Override
   public long getEnvTime() {
      return environment.getEnvTime();
   }

   @Override
   public IExecutionUnitManagement getExecutionUnitManagement() {
      return environment.getExecutionUnitManagement();
   }

   @Override
   public ITestLogger getLogger() {
      return environment.getLogger();
   }

   @Override
   public IScriptControl getScriptCtrl() {
      return environment.getScriptCtrl();
   }

   /*
    * public StatusBoard getStatusBoard() { return environment.getStatusBoard(); }
    */

   @Override
   public ITestStation getTestStation() {
      return environment.getTestStation();
   }

   @Override
   public ITimerControl getTimerCtrl() {
      return environment.getTimerCtrl();
   }

   @Override
   public void onScriptComplete() throws InterruptedException {
      environment.onScriptComplete();
   }

   @Override
   public void onScriptSetup() {
      environment.onScriptSetup();
   }

   @Override
   public ICancelTimer setTimerFor(ITimeout listener, int time) {
      return environment.setTimerFor(listener, time);
   }

   public void logTestPoint(boolean isPassed, String testPointName, String expected, String actual) {
      this.getLogger().testpoint(this.getTestEnvironment(), this.getTestScript(), this, isPassed, testPointName,
         expected, actual);
   }

   public void setPurpose(String purpose) {
      testDescription.setPurpose(purpose);
   }

   public void setPreCondition(String preCondition) {
      testDescription.setPreCondition(preCondition);
   }

   public void setPostCondition(String postCondition) {
      testDescription.setPostCondition(postCondition);
   }

   public List<RequirementRecord> getScriptReqRecordTraceability() {
      return traceability;
   }

   public void addTraceability(String description) {
      this.traceability.add(new RequirementRecord(this.getTestEnvironment(), description));
   }

   public void writeToConsole(String message) {
      TestPrompt p = new TestPrompt(message);

      try {
         testScript.get().prompt(p);
      } catch (Throwable e) {
         OseeLog.log(TestEnvironment.class, Level.INFO, e.getMessage(), e);
      }
   }

   public void setTestScript(TestScript script) {
      throw new IllegalStateException("Why are you calling this one?!?!?!?");
   }

   @Override
   public void abortTestScript(Throwable t) {
      testScript.get().abortDueToThrowable(t);
   }
   
   @JsonProperty
   public List<RequirementRecord> getTraceability() {
       if (traceability.isEmpty()) {
           return null;
       } else {
           return traceability;
       }
   }
   
}