Add state machine Tester friend

compiler/lib/src/main/scala/codegen/CppWriter/StateMachineCppWriter/StateMachineCppWriter.scala

@@ -41,6 +41,7 @@ case class StateMachineCppWriter(
 
   private def getClassMembers: List[CppDoc.Class.Member] =
     List.concat(
+      getFriendClassMembers,
       getTypeMembers,
       getConstructorDestructorMembers,
       getInitMembers,
@@ -295,4 +296,22 @@ case class StateMachineCppWriter(
       CppDoc.Lines.Hpp
     )
 
+  private def getFriendClassMembers: List[CppDoc.Class.Member] = {
+    List(
+      linesClassMember(
+        List(
+          CppDocWriter.writeBannerComment(
+            "Friend classes"
+          ),
+          lines(
+            s"""|
+                |//! Friend class tester implementation to support white-box testing
+                |friend class ${name}Tester;
+                |"""
+          )
+        ).flatten
+      )
+    )
+  }
+
 }

compiler/tools/fpp-to-cpp/test/state-machine/choice/BasicStateMachineAc.ref.hpp

@@ -19,6 +19,13 @@ namespace FppTest {
     //! A basic state machine with a choice
     class BasicStateMachineBase {
 
+        // ----------------------------------------------------------------------
+        // Friend classes
+        // ----------------------------------------------------------------------
+
+        //! Friend class tester implementation to support white-box testing
+        friend class BasicTester;
+
       public:
 
         // ----------------------------------------------------------------------

compiler/tools/fpp-to-cpp/test/state-machine/choice/BasicU32StateMachineAc.ref.hpp

@@ -19,6 +19,13 @@ namespace FppTest {
     //! A basic state machine with a U32 choice
     class BasicU32StateMachineBase {
 
+        // ----------------------------------------------------------------------
+        // Friend classes
+        // ----------------------------------------------------------------------
+
+        //! Friend class tester implementation to support white-box testing
+        friend class BasicU32Tester;
+
       public:
 
         // ----------------------------------------------------------------------

compiler/tools/fpp-to-cpp/test/state-machine/choice/ChoiceToChoiceStateMachineAc.ref.hpp

@@ -20,6 +20,13 @@ namespace FppTest {
     //! with hierarchy
     class ChoiceToChoiceStateMachineBase {
 
+        // ----------------------------------------------------------------------
+        // Friend classes
+        // ----------------------------------------------------------------------
+
+        //! Friend class tester implementation to support white-box testing
+        friend class ChoiceToChoiceTester;
+
       public:
 
         // ----------------------------------------------------------------------

compiler/tools/fpp-to-cpp/test/state-machine/choice/ChoiceToStateStateMachineAc.ref.hpp

@@ -20,6 +20,13 @@ namespace FppTest {
     //! with hierarchy
     class ChoiceToStateStateMachineBase {
 
+        // ----------------------------------------------------------------------
+        // Friend classes
+        // ----------------------------------------------------------------------
+
+        //! Friend class tester implementation to support white-box testing
+        friend class ChoiceToStateTester;
+
       public:
 
         // ----------------------------------------------------------------------

compiler/tools/fpp-to-cpp/test/state-machine/choice/InputPairU16U32StateMachineAc.ref.hpp

@@ -19,6 +19,13 @@ namespace FppTest {
     //! A state machine with two inputs to a choice
     class InputPairU16U32StateMachineBase {
 
+        // ----------------------------------------------------------------------
+        // Friend classes
+        // ----------------------------------------------------------------------
+
+        //! Friend class tester implementation to support white-box testing
+        friend class InputPairU16U32Tester;
+
       public:
 
         // ----------------------------------------------------------------------

compiler/tools/fpp-to-cpp/test/state-machine/choice/SequenceStateMachineAc.ref.hpp

@@ -19,6 +19,13 @@ namespace FppTest {
     //! A basic state machine with a choice sequence
     class SequenceStateMachineBase {
 
+        // ----------------------------------------------------------------------
+        // Friend classes
+        // ----------------------------------------------------------------------
+
+        //! Friend class tester implementation to support white-box testing
+        friend class SequenceTester;
+
       public:
 
         // ----------------------------------------------------------------------

compiler/tools/fpp-to-cpp/test/state-machine/choice/SequenceU32StateMachineAc.ref.hpp

@@ -19,6 +19,13 @@ namespace FppTest {
     //! A basic state machine with a U32 choice sequence
     class SequenceU32StateMachineBase {
 
+        // ----------------------------------------------------------------------
+        // Friend classes
+        // ----------------------------------------------------------------------
+
+        //! Friend class tester implementation to support white-box testing
+        friend class SequenceU32Tester;
+
       public:
 
         // ----------------------------------------------------------------------

compiler/tools/fpp-to-cpp/test/state-machine/initial/BasicStateMachineAc.ref.hpp

@@ -19,6 +19,13 @@ namespace FppTest {
     //! A basic state machine
     class BasicStateMachineBase {
 
+        // ----------------------------------------------------------------------
+        // Friend classes
+        // ----------------------------------------------------------------------
+
+        //! Friend class tester implementation to support white-box testing
+        friend class BasicTester;
+
       public:
 
         // ----------------------------------------------------------------------

compiler/tools/fpp-to-cpp/test/state-machine/initial/ChoiceStateMachineAc.ref.hpp

@@ -19,6 +19,13 @@ namespace FppTest {
     //! A state machine with an initial choice
     class ChoiceStateMachineBase {
 
+        // ----------------------------------------------------------------------
+        // Friend classes
+        // ----------------------------------------------------------------------
+
+        //! Friend class tester implementation to support white-box testing
+        friend class ChoiceTester;
+
       public:
 
         // ----------------------------------------------------------------------

compiler/tools/fpp-to-cpp/test/state-machine/initial/NestedStateMachineAc.ref.hpp

@@ -19,6 +19,13 @@ namespace FppTest {
     //! A state machine with nested initial transitions
     class NestedStateMachineBase {
 
+        // ----------------------------------------------------------------------
+        // Friend classes
+        // ----------------------------------------------------------------------
+
+        //! Friend class tester implementation to support white-box testing
+        friend class NestedTester;
+
       public:
 
         // ----------------------------------------------------------------------

compiler/tools/fpp-to-cpp/test/state-machine/state/BasicGuardStateMachineAc.ref.hpp

@@ -19,6 +19,13 @@ namespace FppTest {
     //! A basic state machine with a guard
     class BasicGuardStateMachineBase {
 
+        // ----------------------------------------------------------------------
+        // Friend classes
+        // ----------------------------------------------------------------------
+
+        //! Friend class tester implementation to support white-box testing
+        friend class BasicGuardTester;
+
       public:
 
         // ----------------------------------------------------------------------

compiler/tools/fpp-to-cpp/test/state-machine/state/BasicGuardStringStateMachineAc.ref.hpp

@@ -19,6 +19,13 @@ namespace FppTest {
     //! A basic state machine with a string guard
     class BasicGuardStringStateMachineBase {
 
+        // ----------------------------------------------------------------------
+        // Friend classes
+        // ----------------------------------------------------------------------
+
+        //! Friend class tester implementation to support white-box testing
+        friend class BasicGuardStringTester;
+
       public:
 
         // ----------------------------------------------------------------------

compiler/tools/fpp-to-cpp/test/state-machine/state/BasicGuardTestAbsTypeStateMachineAc.ref.hpp

@@ -20,6 +20,13 @@ namespace FppTest {
     //! A basic state machine with a TestAbsType guard
     class BasicGuardTestAbsTypeStateMachineBase {
 
+        // ----------------------------------------------------------------------
+        // Friend classes
+        // ----------------------------------------------------------------------
+
+        //! Friend class tester implementation to support white-box testing
+        friend class BasicGuardTestAbsTypeTester;
+
       public:
 
         // ----------------------------------------------------------------------

compiler/tools/fpp-to-cpp/test/state-machine/state/BasicGuardTestArrayStateMachineAc.ref.hpp

@@ -20,6 +20,13 @@ namespace FppTest {
     //! A basic state machine with a TestArray guard
     class BasicGuardTestArrayStateMachineBase {
 
+        // ----------------------------------------------------------------------
+        // Friend classes
+        // ----------------------------------------------------------------------
+
+        //! Friend class tester implementation to support white-box testing
+        friend class BasicGuardTestArrayTester;
+
       public:
 
         // ----------------------------------------------------------------------

compiler/tools/fpp-to-cpp/test/state-machine/state/BasicGuardTestEnumStateMachineAc.ref.hpp

@@ -20,6 +20,13 @@ namespace FppTest {
     //! A basic state machine with a TestEnum guard
     class BasicGuardTestEnumStateMachineBase {
 
+        // ----------------------------------------------------------------------
+        // Friend classes
+        // ----------------------------------------------------------------------
+
+        //! Friend class tester implementation to support white-box testing
+        friend class BasicGuardTestEnumTester;
+
       public:
 
         // ----------------------------------------------------------------------

compiler/tools/fpp-to-cpp/test/state-machine/state/BasicGuardTestStructStateMachineAc.ref.hpp

@@ -20,6 +20,13 @@ namespace FppTest {
     //! A basic state machine with a TestStruct guard
     class BasicGuardTestStructStateMachineBase {
 
+        // ----------------------------------------------------------------------
+        // Friend classes
+        // ----------------------------------------------------------------------
+
+        //! Friend class tester implementation to support white-box testing
+        friend class BasicGuardTestStructTester;
+
       public:
 
         // ----------------------------------------------------------------------

compiler/tools/fpp-to-cpp/test/state-machine/state/BasicGuardU32StateMachineAc.ref.hpp

@@ -19,6 +19,13 @@ namespace FppTest {
     //! A basic state machine with a U32 guard
     class BasicGuardU32StateMachineBase {
 
+        // ----------------------------------------------------------------------
+        // Friend classes
+        // ----------------------------------------------------------------------
+
+        //! Friend class tester implementation to support white-box testing
+        friend class BasicGuardU32Tester;
+
       public:
 
         // ----------------------------------------------------------------------

compiler/tools/fpp-to-cpp/test/state-machine/state/BasicInternalStateMachineAc.ref.hpp

@@ -19,6 +19,13 @@ namespace FppTest {
     //! A basic state machine with an internal transition
     class BasicInternalStateMachineBase {
 
+        // ----------------------------------------------------------------------
+        // Friend classes
+        // ----------------------------------------------------------------------
+
+        //! Friend class tester implementation to support white-box testing
+        friend class BasicInternalTester;
+
       public:
 
         // ----------------------------------------------------------------------

compiler/tools/fpp-to-cpp/test/state-machine/state/BasicSelfStateMachineAc.ref.hpp

@@ -19,6 +19,13 @@ namespace FppTest {
     //! A basic state machine with a self transition
     class BasicSelfStateMachineBase {
 
+        // ----------------------------------------------------------------------
+        // Friend classes
+        // ----------------------------------------------------------------------
+
+        //! Friend class tester implementation to support white-box testing
+        friend class BasicSelfTester;
+
       public:
 
         // ----------------------------------------------------------------------

compiler/tools/fpp-to-cpp/test/state-machine/state/BasicStateMachineAc.ref.hpp

@@ -19,6 +19,13 @@ namespace FppTest {
     //! A basic state machine
     class BasicStateMachineBase {
 
+        // ----------------------------------------------------------------------
+        // Friend classes
+        // ----------------------------------------------------------------------
+
+        //! Friend class tester implementation to support white-box testing
+        friend class BasicTester;
+
       public:
 
         // ----------------------------------------------------------------------

compiler/tools/fpp-to-cpp/test/state-machine/state/BasicStringStateMachineAc.ref.hpp

@@ -19,6 +19,13 @@ namespace FppTest {
     //! A basic state machine with string actions
     class BasicStringStateMachineBase {
 
+        // ----------------------------------------------------------------------
+        // Friend classes
+        // ----------------------------------------------------------------------
+
+        //! Friend class tester implementation to support white-box testing
+        friend class BasicStringTester;
+
       public:
 
         // ----------------------------------------------------------------------

compiler/tools/fpp-to-cpp/test/state-machine/state/BasicTestAbsTypeStateMachineAc.ref.hpp

@@ -20,6 +20,13 @@ namespace FppTest {
     //! A basic state machine with TestAbsType actions
     class BasicTestAbsTypeStateMachineBase {
 
+        // ----------------------------------------------------------------------
+        // Friend classes
+        // ----------------------------------------------------------------------
+
+        //! Friend class tester implementation to support white-box testing
+        friend class BasicTestAbsTypeTester;
+
       public:
 
         // ----------------------------------------------------------------------

compiler/tools/fpp-to-cpp/test/state-machine/state/BasicTestArrayStateMachineAc.ref.hpp

@@ -20,6 +20,13 @@ namespace FppTest {
     //! A basic state machine with TestArray actions
     class BasicTestArrayStateMachineBase {
 
+        // ----------------------------------------------------------------------
+        // Friend classes
+        // ----------------------------------------------------------------------
+
+        //! Friend class tester implementation to support white-box testing
+        friend class BasicTestArrayTester;
+
       public:
 
         // ----------------------------------------------------------------------

compiler/tools/fpp-to-cpp/test/state-machine/state/BasicTestEnumStateMachineAc.ref.hpp

@@ -20,6 +20,13 @@ namespace FppTest {
     //! A basic state machine with TestEnum actions
     class BasicTestEnumStateMachineBase {
 
+        // ----------------------------------------------------------------------
+        // Friend classes
+        // ----------------------------------------------------------------------
+
+        //! Friend class tester implementation to support white-box testing
+        friend class BasicTestEnumTester;
+
       public:
 
         // ----------------------------------------------------------------------

compiler/tools/fpp-to-cpp/test/state-machine/state/BasicTestStructStateMachineAc.ref.hpp

@@ -20,6 +20,13 @@ namespace FppTest {
     //! A basic state machine with TestStruct actions
     class BasicTestStructStateMachineBase {
 
+        // ----------------------------------------------------------------------
+        // Friend classes
+        // ----------------------------------------------------------------------
+
+        //! Friend class tester implementation to support white-box testing
+        friend class BasicTestStructTester;
+
       public:
 
         // ----------------------------------------------------------------------

compiler/tools/fpp-to-cpp/test/state-machine/state/BasicU32StateMachineAc.ref.hpp

@@ -19,6 +19,13 @@ namespace FppTest {
     //! A basic state machine with U32 actions
     class BasicU32StateMachineBase {
 
+        // ----------------------------------------------------------------------
+        // Friend classes
+        // ----------------------------------------------------------------------
+
+        //! Friend class tester implementation to support white-box testing
+        friend class BasicU32Tester;
+
       public:
 
         // ----------------------------------------------------------------------