Harness

** Module   : BarrierElement.java

** Abstract : represents a barrier element in a larger queue

**

**

** -#- -I- --Date-- -----------------------Description------------------------

** 001 GES 20090318 Represents a barrier element in a larger queue.

*/

/*

   {

      return null;

   }

}

** Module   : ConcurrentElements.java

** Abstract : represents multiple elements which must execute simultaneously

**

**

** -#- -I- --Date-- -----------------------Description------------------------

** 001 GES 20090318 Represents multiple elements which must execute

**                  simultaneously.

*/

/*

      return element;

   }

}

** Module   : Driver.java

** Abstract : thread that reads tests from a job queue and executes them

**

**

** -#- -I- --Date-- ---------------------------------------Description----------------------------------------

** 001 GES 20090122 Thread that reads tests from a job queue and executes them.

** 005 TJD 20220808 Changed log format, added option to abort TestSet

** 006 TJD 20220815 Abort anytime if RC failed

** 007 TJD 20220817 Implement test skip list feature, logging tweaks

*/

/*

   private JobQueue<Test> queue = null;

   /** Object to notify when complete. */

   /** Mapping of test executors based on their type. */

   private Map<Class<TestExecutor>, TestExecutor> executors;

    *           The driver's configurations.

    * @param    queue

    *           Job queue from which tests to be executed are obtained.

    *           Object to notify when complete.

    * @param    rc

    *           Object in which to store the details of non-testing failures.

    */

   public Driver(Map<String, SessionSettings> cfgs, 

                 JobQueue<Test>               queue, 

                 FailureNotification          rc)

   {

      this.queue = queue;

      this.cfgs = cfgs;

      this.rc = rc;

   }

   {

      try

      {

         executors = buildExecutors(cfgs, rc);

         if (!pre())

            if (test == null)

            {

               break;

            }

               break;

            }

            // check it test is to be skipped

            {

               // Skipped tests are considered as passed

               LogHelper.info("Skipping test: "+ test.getName());

            }

            test.setDriver(this);

            test.execute();

            Status status = test.getStatus();

            if (status == Status.FAILED)

            {

               FailureMode fail = test.getFailureMode();

                     {

                        backout.setDriver(this);

                        backout.execute();

                     }

                     break;

      }

      catch (Throwable e)

      {

      }

      finally

      {

         post();

      }

   }

** Module   : Harness.java

** Abstract : test execution master driver 

**

**

** -#- -I- --Date-- ---------------------------------------Description----------------------------------------

** 001 GES 20090126 Test execution master driver.

** 010 TJD 20220817 Implement performance test mode and some logging tweaks

** 011 TJD 20220817 Added missing javadoc, include completionMsg

** 012 TJD 20220819 Allow configuring max timeout for single test that require idle waiting

*/

/*

   /** Performance mode enabled flag, enabled with "-m" option, default *false* */

   private static boolean benchmarkMode = false;

   /** Set of names of test to skip */

   private static HashSet<String> skipFileSet = new HashSet<>();

   /** Debug mode enabled flag, enabled with "-d" option, default *false* */

   private static boolean debugMode = false;

   static

   {

         "",

         "-?                    = display this help screen",

         "-d                    = enable verbose output",

         "-l <log_level>        = set log level: WARN,INFO,FINE,FINER",

         "-c                    = enable dumping reports on CTRL-C",

         "-x                    = abort anytime when RC fails",

         "-m [timeout]          = enable performance test mode with optional user I/O wait timeout {60s}",

         "-b <path_list>        = specify a default set of baseline search",

         "                        paths; <path_list> is a list of one or more",

         "                        paths separated by the platform specific",

    * -c                    = enable dump reports on CTRL-C

    * -m [timeout]          = enable performance test mode with optional user I/O wait timeout {60s}

    * -x                    = abort anytime when RC fails,

    *                         paths; <path_list> is a list of one or more

    *                         paths separated by the platform specific

    *                         path separator character (e.g. on UNIX or

    *                         Linux this would be the colon ':')

    * -e                    = force separate host/port/userid/password prompts

    *                         for each target system (the default is to only

    *                         prompt once and to use the same responses

                     break;

                  case "d":

                     break;

                  case "s":

                     // skip file

                     String skipFileName = args[++idx];

                     if ((skipFileName != null) && (skipFileName.length() > 0))

                     {

                        readSkipFile(skipFileName);

                     }

                     break;

                     failOnRCFailure = true;

                     LogHelper.info("Enable immediate fail on any non-testing error mode");

                     break;

                  case "l":

                     // set log level from string

                     if (idx == args.length - 1)

   }

   /**

    * Check if test identified by name is to be skipped

    * @param    name

    *           test name to be checked

   }

   /**

    * Generate a completion message that describes the length of time in

    * human readable terms.

    *

      }

   }

}

** Module   : JobQueue.java

** Abstract : queue tests and allow them to be dequeued based on dependencies

**

**

** -#- -I- --Date-- -----------------------Description------------------------

** 001 GES 20090318 Queue tests and allow them to be dequeued based on

**                  dependencies.

** 002 TJD 20220809 Support for aborting the queue

** 003 TJD 20220817 Implement performance test mode

*/

/*

   /** Flag indicating queue abort was requested */

   private final AtomicBoolean abort = new AtomicBoolean(false);

   /**

    * Construct an instance.

    *

         synchronized (lock)

         {

            ListIterator<SubQueue<E>> list = queue.listIterator();

            // walk through all sub-queues

            while (list.hasNext())

            {

               // do not go past any barrier sub-queues

               if (subQueue.isBarrier())

               {

                  {

                     // all previous sub-queues are finished, remove the

                     // barrier and allow processing to continue

                  // reserve the next element and allow us to safely exit the

                  // synchronized block

               }

            }

         }

         // no sub-queues are ready yet, the current thread must wait for an

               break;

            }

         }

      }

      // the dequeuing is intentionally done outside of the synchronized block

   {

      abort.set(true);

   }

}

** -#- -I- --Date-- -----------------------Description------------------------

** 001 GES 20090318 Represents a set of duplicate elements which are assigned

**                  to a specific thread.

*/

/*

   /** Reservation list. */

   private final Map<Thread, E> reserved = new HashMap<Thread, E>();

   /** Already serviced list (each thread is only ever serviced once). */

   private final Set<Thread> serviced = new HashSet<Thread>();

   public boolean isEmpty()

   {

      boolean empty = false;

      {

      }

      return empty;

   }

   public boolean isReady()

   {

      boolean prev = false;

      synchronized (lock)

      {

         prev = serviced.contains(Thread.currentThread());

      }

   }

   /**

      synchronized (lock)

      {

         element = reserved.remove(Thread.currentThread());

      }

      return element;

   }

** Module   : Report.java

** Abstract : helpful base class for implementing a report

**

**

** -#- -I- --Date-- -----------------------Description------------------------

** 001 GES 20090113 Helpful base class for implementing a report.

** 002 CA  20170404 Add the failed test name in the result summary.

*/

/*

      return num;

   }

}

** Module   : Reportable.java

** Abstract : API for delegating the tracking of a testable activity

**

**

** -#- -I- --Date-- ---------------------------------------Description----------------------------------------

** 001 GES 20090113 API for delegating tracking of a testable activity.

** 002 CA  20210906 The content for description and failure is wrapped only for web tests. 

*/

/*

   public long getElapsed();

   /**

    * Get the short name for the testable activity.

    *

    * @return   A name of the testable activity.

** -#- -I- --Date-- -----------------------Description------------------------

** 001 GES 20090319 Represents elements to be processed in order on a single

**                  thread.

*/

/*

         }

      }

   }

}

** Module   : SingleElement.java

** Abstract : represents a single element in a larger queue

**

**

** -#- -I- --Date-- -----------------------Description------------------------

** 001 GES 20090318 Represents a single element in a larger queue.

*/

/*

   {

      this.element = element;

   }

}

** Module   : Status.java

** Abstract : encodes all possible test and step status codes

**

**

** -#- -I- --Date-- -----------------------Description------------------------

** 001 GES 20081218 Encodes all possible test and step status codes.

*/

/*

   NOT_RUN,

   PASSED,

   FAILED,

}

** Module   : SubQueue.java

** Abstract : API for objects that represent a portion of a larger queue

**

**

** -#- -I- --Date-- -----------------------Description------------------------

** 001 GES 20090318 An API for objects that contain one or more elements that

**                  represent a portion of a larger queue.

*/

/*

    * @return   The next element in the queue.

    */

   public E dequeue();

}

** -#- -I- --Date-- ---------------------------------------Description----------------------------------------

** 001 CA  20210827 Created initial version.

** 002 RFB 20230111 Added finer logging which helps with debug (plus review).

*/

/*

import com.goldencode.harness.terminal.*;

import com.goldencode.harness.test.*;

import com.goldencode.harness.transport.*;

/**

 * The executor for terminal tests.

         // failure details are already in the rc

         return;

      }

      term = new Terminal(new DataSource(is, os), cfg);

   }

   /**

** Module   : TestPlan.java

** Abstract : stores the data needed to execute a list of test sets

**

**

** -#- -I- --Date-- -----------------------Description------------------------

** 001 GES 20090122 Stores the data needed to execute a list of test sets.

** 004 TJD 20220815 Abort anytime if RC failed

** 005 TJD 20220817 Logging tweaks

** 006 TJD 20220819 TestSet are executing sequentially in benchmark mode

*/

/*

   /**

    * Execute each of the test sets that belong to a specific dependency

    *

    * @param    sb

    *           Buffer in which to accumulate error text from failures.

    *

    * @return   The number of failures.

    */

                               Dependency          type,

                               FailureNotification rc)

   {

      int num = 0;

      List<TestSet> list = new ArrayList<TestSet>();

      // create a specific latch of the right size

      iter = list.iterator();

      {

            // wait for test set to finish

            {

               // dump statistics every 60 seconds

               dumpStatistics(list, type);

            }

            // dump statistics every 60 seconds

            dumpStatistics(list, type);

         }

      }

      catch (InterruptedException ie)

      {

         sb.append("test plan thread interrupted before driver ")

         num = 1;

      }

      dumpStatistics(list, type);

      return checkResults(sets, sb, num);

      int testsFailed = 0;

      int testsNotRun = 0;

      int testsTotal = 0;

      for(TestSet testSet:list)

      {

         List<Test> tests = testSet.getTests();

               case NOT_RUN:

                  testsNotRun ++;

                  break;

               case PASSED:

                  testsPassed ++;

                  break;

      }

      double successRate = (testsTotal == testsNotRun) 

                              ? 0.0d 

      double executionRate = (testsTotal == testsNotRun) 

                                ? 0.0d 

                                :(double) (testsPassed + testsFailed)/((double)testsTotal) * 100.0d;

   }

}

** Module   : TestPlanFactory.java

** Abstract : instantiates a test plan from an XML definition 

**

**

** -#- -I- --Date-- ---------------------------------------Description----------------------------------------

** 001 GES 20090122 Instantiates a test plan from an XML definition.

** 003 CA  20210906 Allow override via command line arguments, for: web endpoint, variable initial values and 

**                  oauth1 parameters. 

** 004 CA  20220118 Added Basic authorization.

*/

/*

            processOutputDirectory(root, plan);

            // preload default search paths

            if (testPaths != null)

               index.addTestPathList(testPaths);

** Abstract : stores the data needed to execute a set of tests on a given

**            target host

**

**

** -#- -I- --Date-- ---------------------------------------Description----------------------------------------

** 001 GES 20090122 Stores the data needed to execute a set of tests on a given target host.

** 003 TJD 20220803 Added logging, updated for Java 11

** 004 TJD 20220808 Changed log format, added option to abort TestSet

** 004 TJD 20220815 Logging tweaks

*/

/*

import java.util.*;

import java.util.concurrent.*;

import com.goldencode.harness.test.*;

import com.goldencode.util.*;

   private ResourcePool pool = null;

   /** Semaphore to notify when complete. */

   /** Object in which to log non-testing failures. */

   private FailureNotification rc = null;

   /**

    * Start the thread that executes this test set. See {@link #run}.

    *

    *           Semaphore to notify when the test set completes processing.

    * @param    rc

    *           Object in which to store the details of non-testing failures.

    */

   {

      this.rc  = rc;

      if (cfgs == null || cfgs.isEmpty())

      {

         if (sem != null)

         rc.setResult(ExitCode.MISSING_CONTENT);

         rc.setDetails("Missing session configuration for test set execution.");

         return;

      }

      {

         rc.setResult(ExitCode.MISSING_CONTENT);

         rc.setDetails("Missing semaphore for test set execution.");

      setThreadName(Thread.currentThread().getName());

      StringBuilder  sb     = new StringBuilder();

      int num = 0;

      // start test set timer

      setStartTime(System.currentTimeMillis());

      // start each of the driver threads (there will be at least 1 started)

      for (int i = 0; i < threads; i++)

      {

      }

      try

      {

      }

      catch (InterruptedException ie)

      // end test set timer

      setEndTime(System.currentTimeMillis());

      num = checkResults(tests, sb, num);

      setStatus((num > 0) ? Status.FAILED : Status.PASSED,

                (sb.length() > 0) ? sb.toString() : null);

   }

}

** 007 TJD 20220918 SendText drain mode optimization - shared variable needs to be volatile

** 008 RFB 20230111 Added finer logging which helps with debug. Also removed a return value in a comment

**                  to fix javadoc (plus review).

*/

/*

      this.session = session;

      setTerminalID(cfg.termType);

      // insert a display processor that copies the current screen to a

      // secondary buffer during redrawing

         public void redraw()

         {

            // merge the newly drawn updates into our buffer

            for (int n = 0; n < height; n++)

            {

            // lines have a flag at line number + 1 in the array

            update[0] = false;

            synchronized (lock)

            {

               // create a new, empty snapshot

            try

            {

               int x=0;

               while (true)

               {

                  int i = Terminal.this.session.read(buffer);

                  // watch for EOF

                  if (i < 0)

                     break;

         }

      };

      Thread readerThread = new Thread(reader);

      readerThread.setDaemon(true);

      readerThread.setName("Terminal Reader");

      readerThread.start();

      // wait up to 30 seconds for the 1st screen to come through

      waitForScreen(30000);

   }

   {

      if (text == null || text.length() == 0)

         return;

      delay = Math.max(delay, 50);

      if (Harness.isBenchmarkMode() && delay > 50)

      {

      if (timeout == 0 || waitForScreen(timeout))

      {

         synchronized (lock)

         {

            current = screen;

         }

      }

      return current;

   }

** Module   : LogScreenBuffer.java

** Abstract : directive to query the current screen and store it in the report

**

**

** -#- -I- --Date-- ---------------------------------------Description----------------------------------------

** 001 GES 20090126 Directive to query the current screen and store it in the report.

** 002 CA  20210827 Refactored to allow other test types, beside terminal (which can be executed from the same 

**                  test suite).  Added SOAP and REST web service tests.

*/

/*

   @Override

   public void execute(Terminal term)

   {

      setStatus(Status.PASSED, "");

   }

** Module   : Pause.java

** Abstract : directive to pause for a fixed time interval in milliseconds

**

**

** -#- -I- --Date-- ---------------------------------------Description----------------------------------------

** 001 GES 20090114 Directive to pause for a fixed time interval in milliseconds.

** 002 CA  20210827 Refactored to allow other test types, beside terminal (which can be executed from the same 

**                  test suite).  Added SOAP and REST web service tests.

** 003 TJD 20220817 Implement performance test mode

*/

/*

      setStatus(status, reason);

   }

}

** Module   : ScreenPoller.java

** Abstract : base class to handle common polling logic when examining screens

**

**

** -#- -I- --Date-- ---------------------------------------Description----------------------------------------

** 001 GES 20090210 Base class to handle common polling logic when examining screens.

** 005 TJD 20220817 implemented performance test mode with experimental remove of waits from screen polling,

** 006 TJD 20220818 Fix for performance mode bug

** 007 TJD 20220819 Allow configuring max timeout for single test that require idle waiting

**/

/*

implements TerminalTestable

{

   /** Milliseconds to wait in polling loop. */

   /** Maximum number of milliseconds to wait. */

   private final int millis;

      String   reason = null;

      int      amt        = 0;

      boolean  oneTime    = (millis == 0);

      boolean  indefinite = (millis == -1);

      boolean  failure    = false;

      char[][] screen     = null;

      }

      setDescription(sb.toString());

   }

}

** Module   : SendText.java

** Abstract : implement the send-text step in a test

**

**

** -#- -I- --Date-- -----------------------Description------------------------

** 001 GES 20090113 Implement the send-text step in a test.

*/

/*

import com.goldencode.harness.*;

import com.goldencode.harness.terminal.*;

/**

 * Implement the send-text step in a test. This directive has the