FWD » Core Development » Conversion Tools

**     VVT 2022xxxx JUnit5 dependencies updated to support both existing tests and custom test engine.

**                  See #6237.

    // Adding JUnit5 jar both to client and server, so it will be also deployed to converted projects

    fwdClientServer group: 'org.junit.platform',

                    name: 'junit-platform-engine',

                    version: '1.9.0'

    fwdClientServer group: 'org.junit.jupiter',

                    name: 'junit-jupiter-api',

                    version: '5.9.0'

    fwdClientServer group: 'org.junit.platform',

                    name: 'junit-platform-suite-engine',

                    version: '1.9.0'

    fwdAllTest group: 'org.junit.platform',

                    name: 'junit-platform-console',

                    version: '1.9.0'

    fwdAllTest group: 'org.junit.platform',

                    name: 'junit-platform-engine',

                    version: '1.9.0'

**     VVT 2022xxxx          Copy org.junit.platform.engine.TestEngine file to META-INF/services. See #6237.

      <fileset dir="${manifest.src}" includes="*TestEngine" />

com.goldencode.p2j.testengine.FWDTestEngine

**     VVT 2022xxxx          Two more rulesets processed: unit_test_support and legacy_annotations_post.

**                           See #6237.

   <rule-set name="annotations/unit_test_support" />

   <rule-set name="annotations/legacy_annotations_post" />

**     VVT 2022xxxx Changes in revs. 14243,14241,14239 restored. See #6237.

               <action>ref = execLib("create_java_annotation", pref, "LegacyServiceParameter", -1)</action>

               <!-- Do NOT remove unsupported annotations here, they will be removed in legacy_annotations_post.rules -->

               <!-- <action on="false">ref.remove()</action> -->

         <action>ref = execLib("create_java_annotation", copy, "LegacyService", 1)</action>

            <action>ref = execLib("create_java_annotation", copy, "LegacyService", 1)</action>

         <action>ref = execLib("create_java_annotation", copy, "LegacyService", 1)</action>

            <action>ref = execLib("create_java_annotation", pref, "LegacyWebPath", -1)</action>

**     VVT 2022xxxx Custom test engine annotations are now used instead of that

**                  from the Jupiter test engine. See #6237.

   <worker class="com.goldencode.p2j.uast.UastHintsWorker"       namespace="hints" />

   <worker class="com.goldencode.p2j.convert.ExpressionConversionWorker" namespace="ecw" />

   <func-library access="private">

      <!--

          Create an assignment <attName>=

      -->

      <function name="create_attribute_assignment_right">

         <!-- The parent node -->

         <parameter name="parent" type="com.goldencode.ast.Aast" />

         <!-- the left part attribute name -->

         <parameter name="attName" type="java.lang.String" />

         <return name="tref" type="com.goldencode.ast.Aast" />

         <variable name="chref" type="com.goldencode.ast.Aast" />

         <rule>tref = createProgressAst(prog.assign, "=", parent)</rule>

         <rule>chref = createProgressAst(prog.symbol, attName, tref)</rule>

         <rule>chref.putAnnotation("javaname", attName)</rule>

      </function>

      <!--

          Create an array assignment <attName>=[

      -->

      <function name="create_attribute_array_assignment_right">

         <parameter name="parent" type="com.goldencode.ast.Aast" />

         <parameter name="attName" type="java.lang.String" />

         <return name="tref" type="com.goldencode.ast.Aast" />

         <rule>tref = execLib("create_attribute_assignment_right", parent, attName)</rule>

         <rule>tref = createProgressAst(prog.lbracket, "[", tref)</rule>

      </function>

      <!--

          Lookup legacy annotation attribute value

          Input conditions:

          1. current node is the legacy annotation node

          2. The attName parameter contains the name of the attribute to lookup

          Return: attribute value string of null if this annotation has no attribute with the given name.

      -->

      <function name="lookup_annotation_attribute_string">

         <parameter name="attName" type="java.lang.String" />

         <return name="result" type="java.lang.String" />

         <rule>result = null</rule>

         <variable name="attAssignment" type="com.goldencode.ast.Aast" />

         <!-- Skip the annotation name SYMBOL -->

         <rule>attAssignment = copy.firstChild.nextSibling</rule>

         <while>attAssignment != null

           <!-- Go to the second child, which must be attribute assignment -->

           <rule>attAssignment.type == prog.assign

              <action on="false">compileError(367, "Annotation children must be ASSIGNMENTs")</action>

           </rule>

           <variable name="attNameNode" type="com.goldencode.ast.Aast" />

           <action>attNameNode = attAssignment.firstChild</action>

           <rule>attNameNode.getAnnotation("javaname").equals(attName)

              <action>result = ecw.stripQuotes(attNameNode.nextSibling.getText())</action>

              <break/>

           </rule>

           <action>attAssignment = attAssignment.nextSibling</action>

         </while>      

      </function>

      <function name="create_java_annotation">

         <parameter name="parent" type="com.goldencode.ast.Aast" />

         <parameter name="className" type="java.lang.String" />

         <return name="selectClassesAnno" type="com.goldencode.ast.Aast" />

         <rule>selectClassesAnno = createProgressAst(prog.annotation, "@", parent)</rule>

         <rule>selectClassesAnno.putAnnotation("javaname", className)</rule>

         <!-- ...and mark "our" annotations as preserved -->

         <rule>selectClassesAnno.putAnnotation("fwd", true)</rule>

      </function>

      <!--

          Process ABLUnit @TestSuite annotation:

          1. If the suite includes classes, then create a @SelectClasses(value = {Class1.class, Class2...}) annotation

          2. If the suite includes procedures, then create a @SelectProcedures(value = {"procedure1.p", "procedure2.p"...}) annotation

          3. Create an empty @Suite annotation

          On entry the current node is the annotation.

      -->

      <function name="process_ablunit_test_suite">

         <!-- Create a marker @Suite annotation-->

         <rule>execLib("create_java_annotation", copy.parent, "com.goldencode.p2j.testengine.api.Suite")</rule>

         <!-- Get the "classes" attribute, convert the quoted comma-separated list of class

              names to nodes of prog.symbol type -->

         <variable name="classList" type="java.lang.String" />

         <rule>classList = execLib("lookup_annotation_attribute_string", "classes")</rule>

         <variable name="lref" type="com.goldencode.ast.Aast" />

         <rule>classList != null

            <action>printfln("@TestSuite Classlist %s", classList)</action>

            <!-- Create the @SelectClasses annotation -->

            <variable name="selectClassesAnno" type="com.goldencode.ast.Aast" />

            <action>selectClassesAnno = execLib("create_java_annotation", copy.parent, "com.goldencode.p2j.testengine.api.SelectClasses")</action>

            <!-- Convert comma-separated class name list string into an array of class references -->

            <!--   Create a node of the array type -->

            <action>lref = execLib("create_attribute_array_assignment_right", selectClassesAnno, "value")</action>

            <!-- Parse and convert the comma-separated list -->

            <variable name="classNameList" type="java.util.List" />

            <action>classNameList = createListFromObject(classList.split(","))</action>

            <variable name="classNames" type="java.util.Iterator" />

            <action>classNames = classNameList.iterator()</action>

            <while>classNames.hasNext()

               <variable name="className" type="java.lang.String" />

               <action>className = (#(java.lang.String)classNames.next()).trim()</action>

               <action>printfln("Class name '%s'", className)</action>                                       

               <action>createProgressAst(prog.symbol, sprintf("%s.class", className), lref)</action>

            </while>

         </rule>

         <!-- Get the "procedures" attribute, convert the quoted comma-separated list of procedure

              names to nodes of prog.symbol type -->

         <variable name="procedureList" type="java.lang.String" />

         <rule>procedureList = execLib("lookup_annotation_attribute_string", "procedures")</rule>

         <rule>procedureList != null

            <action>printfln("@TestSuite procedures %s", procedureList)</action>

            <!-- Create the @SelectProcedures annotation -->

            <variable name="selectProceduresAnno" type="com.goldencode.ast.Aast" />

            <action>selectProceduresAnno = execLib("create_java_annotation", copy.parent, "com.goldencode.p2j.testengine.api.SelectProcedures")</action>

            <!-- Convert comma-separated procedure name list string into an array of procedure name strings -->

            <!--   Create a node of the array type -->

            <action>lref = execLib("create_attribute_array_assignment_right", selectProceduresAnno, "value")</action>

            <!-- Parse and convert the comma-separated list -->

            <variable name="procedureNameList" type="java.util.List" />

            <action>procedureNameList = createListFromObject(procedureList.split(","))</action>

            <variable name="procedureNames" type="java.util.Iterator" />

            <action>procedureNames = procedureNameList.iterator()</action>

            <while>procedureNames.hasNext()

               <variable name="procedureName" type="java.lang.String" />

               <action>procedureName = (#(java.lang.String)procedureNames.next()).trim()</action>

               <action>printfln("Procedure name '%s'", procedureName)</action>                                       

               <action>createProgressAst(prog.string, sprintf("'%s'", procedureName), lref)</action>

            </while>

         </rule>

         <!-- Drop the original value -->

         <rule>copy.remove()</rule>

      </function>

   </func-library>

            and (parent.type == prog.method_def

                 or parent.type == prog.procedure

                 or parent.type == prog.class_def)

         <!-- Get required unit test legacy type configuration (hints) -->

         <variable name="unitTestType" type="java.lang.String" />

         <action>unitTestType = hints.getUnitTestType()</action>

         <rule>unitTestType == null

            <action>compileError(223, "No unit test legacy type is configured")</action>

         </rule>

         <variable name="isABLUnit" type="java.lang.Boolean" />

         <action>isABLUnit = unitTestType.equals("ABLUnit")</action>

         <variable name="methodNode" type="com.goldencode.ast.Aast" />

         <action>methodNode = parent.firstChild</action>

         <!-- FIXME: Add similar support for procedures -->

         <action>printfln("method %s is ABL unit test type %s annoName @%s", methodNode.getAnnotation("name"), isABLUnit, annoName)</action>

         <!-- Replace OEUnit/ABLUnit annotation names by corresponding JUnit5 names -->

         <rule>annoName.equalsIgnoreCase("Test")

            <action>newName = "com.goldencode.p2j.testengine.api.Test"</action>

            <!-- Note: the meaning of @Before and @After is opposite in ABLUnit and OEUnit -->

            <rule on="false">annoName.equalsIgnoreCase("Before")

               <rule>isABLUnit

                  <action>newName = "com.goldencode.p2j.testengine.api.BeforeAll"</action>

                  <action on="false">newName = "com.goldencode.p2j.testengine.api.BeforeEach"</action>

               </rule>

               <rule on="false">annoName.equalsIgnoreCase("After")

                  <rule>isABLUnit

                     <action>newName = "com.goldencode.p2j.testengine.api.AfterAll"</action>

                     <action on="false">newName = "com.goldencode.p2j.testengine.api.AfterEach"</action>

                  </rule>

                  <rule on="false">annoName.equalsIgnoreCase("BeforeClass")

                     <action>newName = "com.goldencode.p2j.testengine.api.BeforeAll"</action>

                     <rule on="false">annoName.equalsIgnoreCase("AfterClass")

                        <action>newName = "com.goldencode.p2j.testengine.api.AfterAll"</action>

                        <rule on="false">annoName.equalsIgnoreCase("Ignore")

                           <action>newName = "com.goldencode.p2j.testengine.api.Disabled"</action>

                           <rule on="false">annoName.equalsIgnoreCase("Setup")

                              <action>newName = "com.goldencode.p2j.testengine.api.BeforeEach"</action>

                              <rule on="false">annoName.equalsIgnoreCase("TearDown")

                                 <action>newName = "com.goldencode.p2j.testengine.api.AfterEach"</action>

                                 <!-- ABLUnit @TestSuite(classes="classname1,classname2...", procedures="procedure1.p,procedure2.p...") -->

                                 <rule on="false">annoName.equalsIgnoreCase("TestSuite")

                                    <action>execLib("process_ablunit_test_suite")</action>

                                 </rule>

                              </rule>

                           </rule>

            <action>printfln("newName %s", newName)</action>

            <!-- Write it back... -->

            <action>copy.putAnnotation("javaname", newName)</action>

            <!-- ...and mark "our" annotations as preserved -->

            <action>copy.putAnnotation("fwd", true)</action>

**     VVT 2022xxxx          Changes in revs. 14243,14241,14239 restored. See #6237.

      <rule-set name="convert/unit_test_support" />

**     VVT 2022xxxx  Custom test engine annotations are now used instead of that

**                   from the Jupiter test engine. See #6237.

   <worker class="com.goldencode.p2j.convert.ExpressionConversionWorker" namespace="ecw" />

            and (parent.type == prog.method_def or parent.type == prog.class_def)

            annoName.startsWith("com.goldencode.p2j.testengine.api.")

            <action>copy.putAnnotation("javaname", annoName.substring(34))</action>

      <rule>upPath("ANNOTATION/ASSIGN/LBRACKET")

            and this.type == prog.symbol

         <action>printfln("ANNOTATION/ASSIGN/LBRACKET text '%s'", this.getText())</action>

         <action>createJavaAst(java.reference, ecw.stripQuotes(this.getText()), getClosestPeerId())</action>

      </rule>

         <action>help.createImport("com.goldencode.p2j.testengine.api.*")</action>

**     VVT 2022xxxx          Constant added: default legacy unit test framework type. See #6237. 

   /** Default legacy unit test type */

   public static final String DEF_UNIT_TEST_TYPE = "ABLUnit";

**     VVT 2022xxxx Native methods processInit and getPid made public to be accessible from

**                  FWD test engine. See #6237.

import com.goldencode.p2j.directory.*;

import com.goldencode.p2j.net.Session;

import com.goldencode.p2j.ui.chui.*;

   public static native void processInit();

    * 

    * @return see above 

   public static native long getPid();

    * 

    * @return see above 

   public static native String getUserName();

**     VVT 2022xxxx          UnitTestEngine static network server registration added. See #6237.

import java.util.function.*;

import com.goldencode.p2j.testengine.*;

      RemoteObject.registerStaticNetworkServer(new Class[] { UnitTestEngine.class }, UnitTestServer.class);

   private static void initClassLoaders(DirectoryService ds)

/**

 * 

 */

package com.goldencode.p2j.main;

import com.goldencode.p2j.cfg.*;

/**

 * The purpose of this class is to explore how to start client with no command line.

 */

public class UnitTestDriver

{

   /**

    * The main entry

    * 

    * @param args

    *        for now unused

    */

   public static void main(String[] args)

   {

      // process arguments: either config files of overrides

      // try standard configuration file if none is given

      BootstrapConfig bc = null;

      try

      {

         bc = new BootstrapConfig(null, null, null, null);

      }

      catch (ConfigurationException e)

      {

         e.printStackTrace();

         System.exit(1);

      }

      bc.setServer(false);

      String convo = null;

      try

      {

         convo = bc.getConfigItem("net", "queue", "conversation");

      }

      catch (ConfigurationException ce)

      {

         // ignore

      }

      // default to conversation mode if not specified

      if (convo == null)

      {

         bc.setConfigItem("net", "queue", "conversation", "true");

      }

      // either way, force start thread to false (this client is going to

      // use its main thread as the conversation thread so we don't need

      // to start one

      bc.setConfigItem("net", "queue", "start_thread", "false");

      bc.setConfigItem("net", "server", "host", "localhost");

      bc.setConfigItem("net", "connection", "secure", "false");

      bc.setConfigItem("net", "server", "secure_port", "4434");

      bc.setConfigItem("net", "server", "insecure_port", "4534");

      bc.setConfigItem("client", "driver", "type", "gui_swing");

      bc.setConfigItem("client", "driver", "theme",

               "com.goldencode.p2j.ui.client.gui.theme.Windows10Theme");

      // run the application

      try

      {

         //         if (config.getBoolean("net", "http_client", "disable_ssl_certificate_validation", false))

         //         {

         //            Utils.disableClientSSLCertificateValidation();

         //         }

         //         if (config.getBoolean("client", "mode", "broker", false))

         //         {

         //            setClientLog("broker");

         //            BrokerCore.start(config);

         //         }

         //         else

         //         {

         //            ClientCore.start(config, true, false, this::printDriverDetails);

         //         }

         ClientCore.start(bc, true, false, () -> "");

         // ensure that remaining non-daemon threads don't stop us from closing

         System.exit(0);

      }

      catch (Throwable thr)

      {

         // STOP conditions don't need to be reported, they are an expected

         // mechanism to terminate

         if (ClientCore.isCauseStop(thr))

         {

            System.exit(0);

         }

         thr.printStackTrace(System.err);

         System.err.flush();

         System.exit(-13);

      }

   }

}

/*

** Module   : AbstractBranchTestDescriptor.java

** Abstract : Common accessor for non-terminal test descriptors

**

** Copyright (c) 2022, Golden Code Development Corporation.

**

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

** 001 VVT 2022xxxx Created initial version.

*/

/*

** This program is free software: you can redistribute it and/or modify

** it under the terms of the GNU Affero General Public License as

** published by the Free Software Foundation, either version 3 of the

** License, or (at your option) any later version.

**

** This program is distributed in the hope that it will be useful,

** but WITHOUT ANY WARRANTY; without even the implied warranty of

** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

** GNU Affero General Public License for more details.

**

** You may find a copy of the GNU Affero GPL version 3 at the following

** location: https://www.gnu.org/licenses/agpl-3.0.en.html

** 

** Additional terms under GNU Affero GPL version 3 section 7:

** 

**   Under Section 7 of the GNU Affero GPL version 3, the following additional

**   terms apply to the works covered under the License.  These additional terms

**   are non-permissive additional terms allowed under Section 7 of the GNU

**   Affero GPL version 3 and may not be removed by you.

** 

**   0. Attribution Requirement.

** 

**     You must preserve all legal notices or author attributions in the covered

**     work or Appropriate Legal Notices displayed by works containing the covered

**     work.  You may not remove from the covered work any author or developer

**     credit already included within the covered work.

** 

**   1. No License To Use Trademarks.

** 

**     This license does not grant any license or rights to use the trademarks

**     Golden Code, FWD, any Golden Code or FWD logo, or any other trademarks

**     of Golden Code Development Corporation. You are not authorized to use the

**     name Golden Code, FWD, or the names of any author or contributor, for

**     publicity purposes without written authorization.

** 

**   2. No Misrepresentation of Affiliation.

** 

**     You may not represent yourself as Golden Code Development Corporation or FWD.

** 

**     You may not represent yourself for publicity purposes as associated with

**     Golden Code Development Corporation, FWD, or any author or contributor to

**     the covered work, without written authorization.

** 

**   3. No Misrepresentation of Source or Origin.

** 

**     You may not represent the covered work as solely your work.  All modified

**     versions of the covered work must be marked in a reasonable way to make it

**     clear that the modified work is not originating from Golden Code Development

**     Corporation or FWD.  All modified versions must contain the notices of

**     attribution required in this license.

*/

package com.goldencode.p2j.testengine;

import java.io.*;

import java.util.*;

import org.junit.platform.commons.util.*;

import org.junit.platform.engine.*;

/**

 * This class provides common functions for branch test descriptors

 */

public abstract class AbstractBranchTestDescriptor

extends AbstractFWDTestDescriptor

{

   /** Child descriptors */

   private Set<TestDescriptor> children = Collections.synchronizedSet(new LinkedHashSet<>(16));

   /**

    * The constructor.

    * 

    * @param uniqueId

    *        this descriptor unique ID

    * @param displayName

    *        this descriptor display name

    */

   public AbstractBranchTestDescriptor(final UniqueId uniqueId, final String displayName)

   {

      super(uniqueId, displayName);

   }

   /**

    * Add a <em>child</em> to this descriptor.

    *

    * @param descriptor the child to add to this descriptor; never {@code null}

    */

   @Override

   public void addChild(final TestDescriptor descriptor)

   {

      Preconditions.notNull(descriptor, "child must not be null");

      descriptor.setParent(this);

      children.add(descriptor);

   }

   /**

    * Find the descriptor with the supplied unique ID.

    *

    * <p>The search algorithm begins with this descriptor and then searches

    * through its descendants.

    *

    * @param uniqueId the {@code UniqueId} to search for; never {@code null}

    */

   @Override

   public Optional<? extends TestDescriptor> findByUniqueId(final UniqueId uniqueId)

   {

      if (getUniqueId().equals(uniqueId))

      {

         return Optional.of(this);

      }

      return children.stream().map(child -> child.findByUniqueId(uniqueId))

               .filter(Optional::isPresent).findAny().orElse(Optional.empty());

   }

   /**

    * Get the immutable set of <em>children</em> of this descriptor.

    *

    * @return the set of children of this descriptor; neither {@code null}

    * nor mutable, but potentially empty

    * @see #getDescendants()

    */

   @Override

   public final Set<? extends TestDescriptor> getChildren()

   {

      return Collections.unmodifiableSet(children);

   }

   /**

   * Determine the {@link org.junit.platform.engine.TestDescriptor.Type} of this descriptor.

   *

   * @return the descriptor type; never {@code null}.

   * @see #isContainer()

   * @see #isTest()

   */

   @Override

   public Type getType()

   {

      return Type.CONTAINER;

   }

   /**

    * The object implements the readExternal method to restore its

    * contents by calling the methods of DataInput for primitive

    * types and readObject for objects, strings and arrays.  The

    * readExternal method must read the values in the same sequence

    * and with the same types as were written by writeExternal.

    *

    * @param in the stream to read data from in order to restore the object

    * @exception IOException if I/O errors occur

    * @exception ClassNotFoundException If the class for an object being

    *              restored cannot be found.

    */

   @Override

   public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException

   {

      super.readExternal(in);

      children = (Set<TestDescriptor>) in.readObject();

      for(final TestDescriptor child : children)

      {

         child.setParent(this);

      }

   }

   /**

    * Remove a <em>child</em> from this descriptor.

    *

    * @param descriptor the child to remove from this descriptor; never

    * {@code null}

    */

   @Override

   public void removeChild(TestDescriptor descriptor)

   {

      Preconditions.notNull(descriptor, "child must not be null");

      children.remove(descriptor);

      descriptor.setParent(null);

   }

   /**

    * The object implements the writeExternal method to save its contents

    * by calling the methods of DataOutput for its primitive values or

    * calling the writeObject method of ObjectOutput for objects, strings,

    * and arrays.

    *

    * @serialData Overriding methods should use this tag to describe

    *             the data layout of this Externalizable object.

    *             List the sequence of element types and, if possible,

    *             relate the element to a public/protected field and/or

    *             method of this Externalizable class.

    *

    * @param out the stream to write the object to

    * @exception IOException Includes any I/O exceptions that may occur

    */

   @Override

   public void writeExternal(ObjectOutput out) throws IOException

   {

      super.writeExternal(out);

      out.writeObject(children);

   }

}

/*

** Module   : AbstractClassTestDescriptor.java

** Abstract : Common ancestor for legacy class and legacy procedure test descriptors.

**

** Copyright (c) 2022, Golden Code Development Corporation.

**

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

** 001 VVT 2022xxxx Created initial version.

*/

/*

** This program is free software: you can redistribute it and/or modify

** it under the terms of the GNU Affero General Public License as

** published by the Free Software Foundation, either version 3 of the

** License, or (at your option) any later version.

**

** This program is distributed in the hope that it will be useful,

** but WITHOUT ANY WARRANTY; without even the implied warranty of

** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

** GNU Affero General Public License for more details.

**

** You may find a copy of the GNU Affero GPL version 3 at the following

** location: https://www.gnu.org/licenses/agpl-3.0.en.html

** 

** Additional terms under GNU Affero GPL version 3 section 7:

** 

**   Under Section 7 of the GNU Affero GPL version 3, the following additional

**   terms apply to the works covered under the License.  These additional terms

**   are non-permissive additional terms allowed under Section 7 of the GNU

**   Affero GPL version 3 and may not be removed by you.

** 

**   0. Attribution Requirement.

** 

**     You must preserve all legal notices or author attributions in the covered

**     work or Appropriate Legal Notices displayed by works containing the covered

**     work.  You may not remove from the covered work any author or developer

**     credit already included within the covered work.

** 

**   1. No License To Use Trademarks.

** 

**     This license does not grant any license or rights to use the trademarks

**     Golden Code, FWD, any Golden Code or FWD logo, or any other trademarks

**     of Golden Code Development Corporation. You are not authorized to use the

**     name Golden Code, FWD, or the names of any author or contributor, for

**     publicity purposes without written authorization.

** 

**   2. No Misrepresentation of Affiliation.

** 

**     You may not represent yourself as Golden Code Development Corporation or FWD.

** 

**     You may not represent yourself for publicity purposes as associated with

**     Golden Code Development Corporation, FWD, or any author or contributor to

**     the covered work, without written authorization.

** 

**   3. No Misrepresentation of Source or Origin.

** 

**     You may not represent the covered work as solely your work.  All modified

**     versions of the covered work must be marked in a reasonable way to make it

**     clear that the modified work is not originating from Golden Code Development

**     Corporation or FWD.  All modified versions must contain the notices of

**     attribution required in this license.

*/

package com.goldencode.p2j.testengine;

import java.io.*;

import java.lang.reflect.*;

import java.util.*;

import org.junit.platform.engine.*;

import com.goldencode.util.*;

/**

 * Common ancestor for legacy class and legacy procedure test descriptors.

 */

public abstract class AbstractClassTestDescriptor

extends AbstractBranchTestDescriptor

{

   /**

    * Class methods marked to execute before all tests 

    */

   List<Method> afterAll;

   /**

    * Class methods marked to execute before all tests 

    */

   List<Method> beforeAll;

   /**

    * The Java class.

    */

   Class clazz;

   /**

    * Default constructor. Required for serialization. Not to be used in application code.

    */

   protected AbstractClassTestDescriptor()

   {

      super(null, null);

      this.clazz = null;

      this.beforeAll = null;

      this.afterAll = null;      

   }

   /**

    * The constructor.

    * 

    * @param clazz

    *        the Java class

    * @param parent

    *        the parent descriptor

    * @param test

    *        class methods marked as tests  

    * @param beforeEach

    *        class methods marked to execute before each test  

    * @param afterEach

    *        class methods marked to execute after each test  

    * @param beforeAll

    *        class methods marked to execute before all tests  

    * @param afterAll

    *        class methods marked to execute after all tests  

    */

   protected AbstractClassTestDescriptor(final Class<?> clazz, final TestDescriptor parent,

            final List<Method> test, final List<Method> beforeEach, final List<Method> afterEach,

            final List<Method> beforeAll, final List<Method> afterAll)

   {

      super(parent.getUniqueId().append("class", clazz.getName()), clazz.getSimpleName());

      this.clazz = clazz;

      this.beforeAll = beforeAll;

      this.afterAll = afterAll;

   }

   /**

    * Execute the <em>after</em> behavior of this node implementation.

    *

    * <p>This method will be called once <em>after</em> {@linkplain #executeImpl()

    * execution} of this node.

    * 

    * @throws Exception 

    * 

    */

   @Override

   public void afterImpl() throws Exception

   {

      callMethodsImpl(afterAll);

   }

   /**

    * Execute the <em>before</em> behavior of this node implementation.

    *

    * <p>This method will be called once <em>before</em> {@linkplain #executeImpl()

    * execution} of this node.

    * 

    * @throws Exception 

    *

    */

   @Override

   public void beforeImpl() throws Exception

   {

      callMethodsImpl(beforeAll);

   }

   /**

    * Print all class-specific fields.

    * 

    * @param printer

    *        the string printer to print into

    */

   @Override

   public void print(PrintHelper printer)

   {

      printer.print(clazz.getName());

   }

   /**

    * The object implements the readExternal method to restore its

    * contents by calling the methods of DataInput for primitive

    * types and readObject for objects, strings and arrays.  The

    * readExternal method must read the values in the same sequence

    * and with the same types as were written by writeExternal.

    *

    * @param in the stream to read data from in order to restore the object

    * @exception IOException if I/O errors occur

    * @exception ClassNotFoundException If the class for an object being

    *              restored cannot be found.

    */

   @Override

   public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException

   {

      super.readExternal(in);

      clazz = (Class<?>) in.readObject();

      beforeAll = SerializationSupport.readMethods(in);

      afterAll = SerializationSupport.readMethods(in);

   }

   /**

    * The object implements the writeExternal method to save its contents

    * by calling the methods of DataOutput for its primitive values or

    * calling the writeObject method of ObjectOutput for objects, strings,

    * and arrays.

    *

    * @serialData Overriding methods should use this tag to describe

    *             the data layout of this Externalizable object.

    *             List the sequence of element types and, if possible,

    *             relate the element to a public/protected field and/or

    *             method of this Externalizable class.

    *

    * @param out the stream to write the object to

    * @exception IOException Includes any I/O exceptions that may occur

    */

   @Override

   public void writeExternal(ObjectOutput out) throws IOException

   {

      super.writeExternal(out);

      out.writeObject(clazz);

      SerializationSupport.writeMethods(beforeAll, out);

      SerializationSupport.writeMethods(afterAll, out);

   }

}

/*

** Module   : AbstractDWDTestDescriptor.java

** Abstract : Common accessor for all test descriptors

**

** Copyright (c) 2022, Golden Code Development Corporation.

**

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

** 001 VVT 2022xxxx Created initial version.

*/

/*

** This program is free software: you can redistribute it and/or modify

** it under the terms of the GNU Affero General Public License as

** published by the Free Software Foundation, either version 3 of the

** License, or (at your option) any later version.

**

** This program is distributed in the hope that it will be useful,

** but WITHOUT ANY WARRANTY; without even the implied warranty of

** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

** GNU Affero General Public License for more details.

**

** You may find a copy of the GNU Affero GPL version 3 at the following

** location: https://www.gnu.org/licenses/agpl-3.0.en.html

** 

** Additional terms under GNU Affero GPL version 3 section 7:

** 

**   Under Section 7 of the GNU Affero GPL version 3, the following additional

**   terms apply to the works covered under the License.  These additional terms

**   are non-permissive additional terms allowed under Section 7 of the GNU

**   Affero GPL version 3 and may not be removed by you.

** 

**   0. Attribution Requirement.

** 

**     You must preserve all legal notices or author attributions in the covered

**     work or Appropriate Legal Notices displayed by works containing the covered

**     work.  You may not remove from the covered work any author or developer

**     credit already included within the covered work.

** 

**   1. No License To Use Trademarks.

** 

**     This license does not grant any license or rights to use the trademarks

**     Golden Code, FWD, any Golden Code or FWD logo, or any other trademarks

**     of Golden Code Development Corporation. You are not authorized to use the

**     name Golden Code, FWD, or the names of any author or contributor, for

**     publicity purposes without written authorization.

** 

**   2. No Misrepresentation of Affiliation.

** 

**     You may not represent yourself as Golden Code Development Corporation or FWD.

** 

**     You may not represent yourself for publicity purposes as associated with

**     Golden Code Development Corporation, FWD, or any author or contributor to

**     the covered work, without written authorization.

** 

**   3. No Misrepresentation of Source or Origin.

** 

**     You may not represent the covered work as solely your work.  All modified

**     versions of the covered work must be marked in a reasonable way to make it

**     clear that the modified work is not originating from Golden Code Development

**     Corporation or FWD.  All modified versions must contain the notices of

**     attribution required in this license.

*/

package com.goldencode.p2j.testengine;

import java.lang.reflect.*;

import java.util.*;

import org.junit.platform.engine.*;

import org.junit.platform.engine.support.hierarchical.*;

/**

 * This class provides common functions for all FWD test descriptors:

 * 

 * <li>Stores unique ID, display name and parent reference.

 * <li>Serialization: FWD test descriptors travel over network, so they must be serializable.

 * <li>Implements {@link Node} interface: all methods are passed to a proxy to be executed on the server.

 */

public abstract class AbstractFWDTestDescriptor

extends NoopDescriptor

implements Node<FWDEngineExecutionContext>

{

   /**

    * The constructor.

    * 

    * @param uniqueId

    *        the descriptor unique ID

    * @param displayName

    *        the descriptor display name

    */

   public AbstractFWDTestDescriptor(final UniqueId uniqueId, final String displayName)

   {

      super(uniqueId, displayName);

   }

   /**

    * Default constructor. Must be used internally for serialization only.

    */

   protected AbstractFWDTestDescriptor()

   {

      this(null, null);

   }

   /**

    * Execute the <em>after</em> behavior of this node.

    *

    * <p>This method will be called once <em>after</em> {@linkplain #execute

    * execution} of this node.

    *

    * @param context

    *        the context to execute in

    * 

    */

   @Override

   public void after(final FWDEngineExecutionContext context) throws Exception

   {

      context.unitTestSupport.after(getUniqueId());

   }

   /**

    * Execute the <em>after</em> behavior of this node implementation.

    *

    * <p>This method will be called once <em>after</em> {@linkplain #executeImpl()

    * execution} of this node.

    * 

    * @throws Exception 

    * 

    */

   public void afterImpl() throws Exception

   {

      // no-op

   }

   /**

    * Execute the <em>before</em> behavior of this node.

    *

    * <p>This method will be called once <em>before</em> {@linkplain #execute

    * execution} of this node.

    *

    * @param context

    *        the context to execute in

    * @return the new context to be used for children of this node; never

    * {@code null}

    */

   @Override

   public FWDEngineExecutionContext before(FWDEngineExecutionContext context) throws Exception

   {

      context.unitTestSupport.before(getUniqueId());

      return context;

   }

   /**

    * Execute the <em>before</em> behavior of this node implementation.

    *

    * <p>This method will be called once <em>before</em> {@linkplain #executeImpl()

    * execution} of this node.

    * 

    * @throws Exception 

    *

    */

   public void beforeImpl() throws Exception

   {

      // no-op

   }

   /**

    * Clean up the supplied {@code context} after execution.

    * 

    * Reset the test class instance.

    *

    * @param context

    *        the context to execute in

    * @see #prepare

    */

   @Override

   public void cleanUp(final FWDEngineExecutionContext context) throws Exception

   {

      context.unitTestSupport.cleanUp(getUniqueId());

   }

   /**

    * Clean up the supplied {@code context} after execution implementation.

    * 

    * Reset the test class instance.

    * 

    * @throws Exception 

    *

    * @see #prepare

    */

   public void cleanUpImpl() throws Exception

   {

      // no-op

   }

   /**

    * Execute the <em>behavior</em> of this node.

    *

    * <p>Containers typically do not implement this method since the

    * {@link HierarchicalTestEngine} handles execution of their children.

    *

    * <p>The supplied {@code dynamicTestExecutor} may be used to submit

    * additional dynamic tests for immediate execution.

    *

    * @param context

    *         the context to execute in

    * @param dynamicTestExecutor

    *        the executor to submit dynamic tests to

    *        

    * @return the new context to be used for children of this node and for the

    * <em>after</em> behavior of the parent of this node, if any

    */

   @Override

   public FWDEngineExecutionContext execute(final FWDEngineExecutionContext context,

            DynamicTestExecutor dynamicTestExecutor) throws Exception

   {

      context.unitTestSupport.execute(getUniqueId());

      return context;

   }

   /**

    * Execute the implementation <em>behavior</em> of this node.

    *

    * @throws Exception 

    *

    */

   public void executeImpl() throws Exception

   {

      // no-op

   }

   /**

    * Prepare the supplied {@code context} prior to execution.

    * 

    * Create test class instance.

    *

    * @see #cleanUp

    */

   @Override

   public FWDEngineExecutionContext prepare(FWDEngineExecutionContext context) throws Exception

   {

      context.unitTestSupport.prepare(getUniqueId());

      return context;

   }

   /**

    * Prepare the supplied {@code context} prior to execution implementation.

    * 

    * @throws Exception 

    *

    * @see #cleanUpImpl

    */

   public void prepareImpl() throws Exception

   {

      // no-op

   }

   /**

   * Returns a string representation of the object. In general, the

   * {@code toString} method returns a string that

   * "textually represents" this object. The result should

   * be a concise but informative representation that is easy for a

   * person to read.

   * It is recommended that all subclasses override this method.

   * <p>

   * The {@code toString} method for class {@code Object}

   * returns a string consisting of the name of the class of which the

   * object is an instance, the at-sign character `{@code @}', and

   * the unsigned hexadecimal representation of the hash code of the

   * object. In other words, this method returns a string equal to the

   * value of:

   * <blockquote>

   * <pre>

   * getClass().getName() + '@' + Integer.toHexString(hashCode())

   * </pre></blockquote>