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.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">

      <!-- FIXME: functions in this library are mostly copied from the legacy_services.rules.

           they should probably go to some public library -->

      <!--

          Create an assignment <attName>=

      -->

      <function name="assign_field_part">

         <!-- 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 assignment <attName>=[

      -->

      <function name="assign_field_array">

         <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("assign_field_part", parent, attName)</rule>

         <rule>tref = createProgressAst(prog.lbracket, "[", tref)</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>

                        <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>

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

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

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

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

                                         names to nodes of prog.symbol type -->

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

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

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

                                    <action>ref = copy.getChildAt(1)</action>

                                    <rule>ref == null

                                       <action>compileError(367, "@SelectClasses annotation must have a child")</action>

                                    </rule>

                                    <rule>ref.type == prog.assign

                                       <action on="false">compileError(367, "@SelectClasses children must have the assignment type")</action>

                                    </rule>

                                    <action>ref = ref.firstChild</action>

                                    <rule>ref.getAnnotation("javaname").equals("value")

                                       <action on="false">compileError(367, "@SelectClasses: attribute name must be 'value'")</action>

                                    </rule>

                                    <!-- Go to second child od ASSIGN, which must be a STRING literal -->

                                    <action>ref = ref.nextSibling</action>

                                    <rule>ref.type == prog.string and ref.getAnnotation("is-literal").equals("true")

                                       <action>compileError(367, "@SelectClasses attribute assignment right part must be a string literal")</action>

                                    </rule>

                                    <!-- Get the value of the "value" attribute ofthe annotation, strip surrounding quotes -->

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

                                    <action>classList = ecw.stripQuotes(ref.getText())</action>

                                    <!-- Now we can drop the original value -->

                                    <action>ref.getParent().remove()</action>

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

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

                                    <action>ref = execLib("assign_field_array", copy, "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), ref)</action>

                                    </while>            

                                 </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.io.*;

import java.lang.reflect.*;

import java.util.*;

import org.junit.platform.engine.*;

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

import com.goldencode.util.*;

/**

 * 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

implements Externalizable,

           TestDescriptor,

           Node<FWDEngineExecutionContext>,

           Printable

{

   /** This descriptor display name */

   private String displayName;

   /** The parent descriptor or {@code null} if this is the root (test engine) descriptor */

   private TestDescriptor parent;

   /** The descriptor unique ID */

   private UniqueId uniqueId;

   /**

    * The constructor.

    * 

    * @param uniqueId

    *        the descriptor unique ID

    * @param displayName

    *        the descriptor display name

    */

   public AbstractFWDTestDescriptor(final UniqueId uniqueId, final String displayName)

   {

      this.uniqueId = uniqueId;

      this.displayName = displayName;

   }

   /**

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

    */

   protected AbstractFWDTestDescriptor()

   {

      this(null, null);

   }

   /**

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

    *

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

    */

   @Override

   public void addChild(TestDescriptor descriptor)

   {

      // Default is the terminal node implementation, must be re-defined for branch nodes

      throw new RuntimeException("Not supported");

   }

   /**

    * 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

   }

   /**

    * Indicates whether some other object is "equal to" this one.

    * <p>

    * The {@code equals} method implements an equivalence relation

    * on non-null object references:

    * <ul>

    * <li>It is <i>reflexive</i>: for any non-null reference value

    *     {@code x}, {@code x.equals(x)} should return

    *     {@code true}.

    * <li>It is <i>symmetric</i>: for any non-null reference values

    *     {@code x} and {@code y}, {@code x.equals(y)}

    *     should return {@code true} if and only if

    *     {@code y.equals(x)} returns {@code true}.

    * <li>It is <i>transitive</i>: for any non-null reference values

    *     {@code x}, {@code y}, and {@code z}, if

    *     {@code x.equals(y)} returns {@code true} and

    *     {@code y.equals(z)} returns {@code true}, then

    *     {@code x.equals(z)} should return {@code true}.

    * <li>It is <i>consistent</i>: for any non-null reference values

    *     {@code x} and {@code y}, multiple invocations of

    *     {@code x.equals(y)} consistently return {@code true}

    *     or consistently return {@code false}, provided no

    *     information used in {@code equals} comparisons on the

    *     objects is modified.

    * <li>For any non-null reference value {@code x},

    *     {@code x.equals(null)} should return {@code false}.

    * </ul>

    * <p>

    * The {@code equals} method for class {@code Object} implements

    * the most discriminating possible equivalence relation on objects;

    * that is, for any non-null reference values {@code x} and

    * {@code y}, this method returns {@code true} if and only

    * if {@code x} and {@code y} refer to the same object

    * ({@code x == y} has the value {@code true}).

    * <p>

    * Note that it is generally necessary to override the {@code hashCode}

    * method whenever this method is overridden, so as to maintain the

    * general contract for the {@code hashCode} method, which states

    * that equal objects must have equal hash codes.

    *

    * @param   obj   the reference object with which to compare.

    * @return  {@code true} if this object is the same as the obj

    *          argument; {@code false} otherwise.

    * @see     #hashCode()

    * @see     java.util.HashMap

    */

   @Override

   public final boolean equals(Object obj)

   {

      // Test descriptors are compared by their unique IDs.

      if (obj == null)

      {

         return false;

      }

      if (this.getClass() != obj.getClass())

      {

         return false;

      }

      return uniqueId.equals(((TestDescriptor) obj).getUniqueId());

   }

   /**

    * 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

   }

   /**

    * 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)

   {

      return Optional.of(this.uniqueId.equals(uniqueId) ? this : null);

   }

   /**

    * 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 Set<? extends TestDescriptor> getChildren()

   {

      return Collections.emptySet();

   }

   /**