From d92963dc4a89d8884f79d1d9c7c1b6ec27524f77 Mon Sep 17 00:00:00 2001 From: Rob Bocchino Date: Mon, 17 Nov 2025 20:23:27 -0800 Subject: [PATCH] Revise tests for port invocations --- .../test/top/TypedPortsTopologyAc.ref.cpp | 397 +++++++++++++++++- .../TypedPorts/PassiveReceiver.hpp | 56 ++- .../tools/fpp-to-cpp/test/top/typed_ports.fpp | 52 ++- 3 files changed, 486 insertions(+), 19 deletions(-) diff --git a/compiler/tools/fpp-to-cpp/test/top/TypedPortsTopologyAc.ref.cpp b/compiler/tools/fpp-to-cpp/test/top/TypedPortsTopologyAc.ref.cpp index 21540edb4..c22d7aa9a 100644 --- a/compiler/tools/fpp-to-cpp/test/top/TypedPortsTopologyAc.ref.cpp +++ b/compiler/tools/fpp-to-cpp/test/top/TypedPortsTopologyAc.ref.cpp @@ -49,7 +49,7 @@ namespace M { // C M::passiveSender.set_p1_OutputPort( 0, - M::passiveReceiver.get_p1_InputPort(0) + M::passiveReceiver.get_p1_InputPort(1) ); M::passiveSender.set_p1_OutputPort( 1, @@ -69,7 +69,47 @@ namespace M { ); M::passiveSender.set_p3_OutputPort( 1, - M::passiveReceiver.get_p3_InputPort(0) + M::passiveReceiver.get_p3_InputPort(1) + ); + M::passiveSender.set_p4_OutputPort( + 0, + M::passiveReceiver.get_p4_InputPort(0) + ); + M::passiveSender.set_p4_OutputPort( + 1, + M::passiveReceiver.get_p4_InputPort(0) + ); + M::passiveSender.set_p5_OutputPort( + 0, + M::passiveReceiver.get_p5_InputPort(0) + ); + M::passiveSender.set_p5_OutputPort( + 1, + M::passiveReceiver.get_p5_InputPort(0) + ); + M::passiveSender.set_p6_OutputPort( + 0, + M::passiveReceiver.get_p6_InputPort(0) + ); + M::passiveSender.set_p6_OutputPort( + 1, + M::passiveReceiver.get_p6_InputPort(0) + ); + M::passiveSender.set_p7_OutputPort( + 0, + M::passiveReceiver.get_p7_InputPort(0) + ); + M::passiveSender.set_p7_OutputPort( + 1, + M::passiveReceiver.get_p7_InputPort(0) + ); + M::passiveSender.set_p8_OutputPort( + 0, + M::passiveReceiver.get_p8_InputPort(0) + ); + M::passiveSender.set_p8_OutputPort( + 1, + M::passiveReceiver.get_p8_InputPort(0) ); #endif @@ -219,10 +259,155 @@ namespace M { return result; } + bool PassiveSenderComponentBase::isConnected_p4_OutputPort(FwIndexType portNum) const { + FW_ASSERT( + (0 <= portNum) && (portNum < NUM_P4_OUTPUT_PORTS), + static_cast(portNum), + static_cast(NUM_P4_OUTPUT_PORTS) + ); + bool result = false; + const auto instance = this->getInstance(); + switch (instance) { + case ::M::InstanceIds::M_passiveSender: + switch (portNum) { + case 0: + result = true; + break; + case 1: + result = true; + break; + default: + break; + } + break; + default: + FW_ASSERT(0, static_cast(instance)); + break; + } + return result; + } + + bool PassiveSenderComponentBase::isConnected_p5_OutputPort(FwIndexType portNum) const { + FW_ASSERT( + (0 <= portNum) && (portNum < NUM_P5_OUTPUT_PORTS), + static_cast(portNum), + static_cast(NUM_P5_OUTPUT_PORTS) + ); + bool result = false; + const auto instance = this->getInstance(); + switch (instance) { + case ::M::InstanceIds::M_passiveSender: + switch (portNum) { + case 0: + result = true; + break; + case 1: + result = true; + break; + default: + break; + } + break; + default: + FW_ASSERT(0, static_cast(instance)); + break; + } + return result; + } + + bool PassiveSenderComponentBase::isConnected_p6_OutputPort(FwIndexType portNum) const { + FW_ASSERT( + (0 <= portNum) && (portNum < NUM_P6_OUTPUT_PORTS), + static_cast(portNum), + static_cast(NUM_P6_OUTPUT_PORTS) + ); + bool result = false; + const auto instance = this->getInstance(); + switch (instance) { + case ::M::InstanceIds::M_passiveSender: + switch (portNum) { + case 0: + result = true; + break; + case 1: + result = true; + break; + default: + break; + } + break; + default: + FW_ASSERT(0, static_cast(instance)); + break; + } + return result; + } + + bool PassiveSenderComponentBase::isConnected_p7_OutputPort(FwIndexType portNum) const { + FW_ASSERT( + (0 <= portNum) && (portNum < NUM_P7_OUTPUT_PORTS), + static_cast(portNum), + static_cast(NUM_P7_OUTPUT_PORTS) + ); + bool result = false; + const auto instance = this->getInstance(); + switch (instance) { + case ::M::InstanceIds::M_passiveSender: + switch (portNum) { + case 0: + result = true; + break; + case 1: + result = true; + break; + default: + break; + } + break; + default: + FW_ASSERT(0, static_cast(instance)); + break; + } + return result; + } + + bool PassiveSenderComponentBase::isConnected_p8_OutputPort(FwIndexType portNum) const { + FW_ASSERT( + (0 <= portNum) && (portNum < NUM_P8_OUTPUT_PORTS), + static_cast(portNum), + static_cast(NUM_P8_OUTPUT_PORTS) + ); + bool result = false; + const auto instance = this->getInstance(); + switch (instance) { + case ::M::InstanceIds::M_passiveSender: + switch (portNum) { + case 0: + result = true; + break; + case 1: + result = true; + break; + default: + break; + } + break; + default: + FW_ASSERT(0, static_cast(instance)); + break; + } + return result; + } + void PassiveSenderComponentBase::p1_out( FwIndexType portNum, U32 x1, - F32 x2 + F32 x2, + bool x3, + const Fw::StringBase& x4, + const M::A& x5, + const M::E& x6, + const M::S& x7 ) const { FW_ASSERT( (0 <= portNum) && (portNum < NUM_P1_OUTPUT_PORTS), @@ -235,16 +420,26 @@ namespace M { switch (portNum) { case 0: M::passiveReceiver.p1_handlerBase( - 0, + 1, x1, - x2 + x2, + x3, + x4, + x5, + x6, + x7 ); break; case 1: M::passiveReceiver.p1_handlerBase( 0, x1, - x2 + x2, + x3, + x4, + x5, + x6, + x7 ); break; default: @@ -318,6 +513,196 @@ namespace M { break; case 1: _result = M::passiveReceiver.p3_handlerBase( + 1, + x + ); + break; + default: + FW_ASSERT(0, static_cast(portNum)); + break; + } + break; + default: + FW_ASSERT(0, static_cast(instance)); + break; + } + return _result; + } + + bool PassiveSenderComponentBase::p4_out( + FwIndexType portNum, + bool x + ) const { + FW_ASSERT( + (0 <= portNum) && (portNum < NUM_P4_OUTPUT_PORTS), + static_cast(portNum), + static_cast(NUM_P4_OUTPUT_PORTS) + ); + const auto instance = this->getInstance(); + bool _result = {}; + switch (instance) { + case ::M::InstanceIds::M_passiveSender: + switch (portNum) { + case 0: + _result = M::passiveReceiver.p4_handlerBase( + 0, + x + ); + break; + case 1: + _result = M::passiveReceiver.p4_handlerBase( + 0, + x + ); + break; + default: + FW_ASSERT(0, static_cast(portNum)); + break; + } + break; + default: + FW_ASSERT(0, static_cast(instance)); + break; + } + return _result; + } + + Fw::String PassiveSenderComponentBase::p5_out( + FwIndexType portNum, + const Fw::StringBase& x + ) const { + FW_ASSERT( + (0 <= portNum) && (portNum < NUM_P5_OUTPUT_PORTS), + static_cast(portNum), + static_cast(NUM_P5_OUTPUT_PORTS) + ); + const auto instance = this->getInstance(); + Fw::String _result = {}; + switch (instance) { + case ::M::InstanceIds::M_passiveSender: + switch (portNum) { + case 0: + _result = M::passiveReceiver.p5_handlerBase( + 0, + x + ); + break; + case 1: + _result = M::passiveReceiver.p5_handlerBase( + 0, + x + ); + break; + default: + FW_ASSERT(0, static_cast(portNum)); + break; + } + break; + default: + FW_ASSERT(0, static_cast(instance)); + break; + } + return _result; + } + + M::A PassiveSenderComponentBase::p6_out( + FwIndexType portNum, + const M::A& x + ) const { + FW_ASSERT( + (0 <= portNum) && (portNum < NUM_P6_OUTPUT_PORTS), + static_cast(portNum), + static_cast(NUM_P6_OUTPUT_PORTS) + ); + const auto instance = this->getInstance(); + M::A _result = {}; + switch (instance) { + case ::M::InstanceIds::M_passiveSender: + switch (portNum) { + case 0: + _result = M::passiveReceiver.p6_handlerBase( + 0, + x + ); + break; + case 1: + _result = M::passiveReceiver.p6_handlerBase( + 0, + x + ); + break; + default: + FW_ASSERT(0, static_cast(portNum)); + break; + } + break; + default: + FW_ASSERT(0, static_cast(instance)); + break; + } + return _result; + } + + M::E PassiveSenderComponentBase::p7_out( + FwIndexType portNum, + const M::E& x + ) const { + FW_ASSERT( + (0 <= portNum) && (portNum < NUM_P7_OUTPUT_PORTS), + static_cast(portNum), + static_cast(NUM_P7_OUTPUT_PORTS) + ); + const auto instance = this->getInstance(); + M::E _result = {}; + switch (instance) { + case ::M::InstanceIds::M_passiveSender: + switch (portNum) { + case 0: + _result = M::passiveReceiver.p7_handlerBase( + 0, + x + ); + break; + case 1: + _result = M::passiveReceiver.p7_handlerBase( + 0, + x + ); + break; + default: + FW_ASSERT(0, static_cast(portNum)); + break; + } + break; + default: + FW_ASSERT(0, static_cast(instance)); + break; + } + return _result; + } + + M::S PassiveSenderComponentBase::p8_out( + FwIndexType portNum, + const M::S& x + ) const { + FW_ASSERT( + (0 <= portNum) && (portNum < NUM_P8_OUTPUT_PORTS), + static_cast(portNum), + static_cast(NUM_P8_OUTPUT_PORTS) + ); + const auto instance = this->getInstance(); + M::S _result = {}; + switch (instance) { + case ::M::InstanceIds::M_passiveSender: + switch (portNum) { + case 0: + _result = M::passiveReceiver.p8_handlerBase( + 0, + x + ); + break; + case 1: + _result = M::passiveReceiver.p8_handlerBase( 0, x ); diff --git a/compiler/tools/fpp-to-cpp/test/top/check-cpp-dir/TypedPorts/PassiveReceiver.hpp b/compiler/tools/fpp-to-cpp/test/top/check-cpp-dir/TypedPorts/PassiveReceiver.hpp index 2f21b02c6..3b90fa0ee 100644 --- a/compiler/tools/fpp-to-cpp/test/top/check-cpp-dir/TypedPorts/PassiveReceiver.hpp +++ b/compiler/tools/fpp-to-cpp/test/top/check-cpp-dir/TypedPorts/PassiveReceiver.hpp @@ -5,7 +5,7 @@ namespace M { - class PassiveReceiver : + class PassiveReceiver final : public PassiveReceiverComponentBase { @@ -19,25 +19,65 @@ namespace M { } - virtual void p1_handler( + void p1_handler( FwIndexType portNum, U32 x1, - F32 x2 - ) { + F32 x2, + bool x3, + const Fw::StringBase& x4, + const M::A& x5, + const M::E& x6, + const M::S& x7 + ) override { } - virtual U32 p2_handler( + U32 p2_handler( FwIndexType portNum, U32 x - ) { + ) override { return x; } - virtual F32 p3_handler( + F32 p3_handler( FwIndexType portNum, F32 x - ) { + ) override { + return x; + } + + bool p4_handler( + FwIndexType portNum, + bool x + ) override { + return x; + } + + Fw::String p5_handler( + FwIndexType portNum, + const Fw::StringBase& x + ) override { + return x; + } + + M::A p6_handler( + FwIndexType portNum, + const M::A& x + ) override { + return x; + } + + M::E p7_handler( + FwIndexType portNum, + const M::E& x + ) override { + return x; + } + + M::S p8_handler( + FwIndexType portNum, + const M::S& x + ) override { return x; } diff --git a/compiler/tools/fpp-to-cpp/test/top/typed_ports.fpp b/compiler/tools/fpp-to-cpp/test/top/typed_ports.fpp index 0183c64ff..d4a13926c 100644 --- a/compiler/tools/fpp-to-cpp/test/top/typed_ports.fpp +++ b/compiler/tools/fpp-to-cpp/test/top/typed_ports.fpp @@ -1,14 +1,36 @@ module M { - port P1(x1: U32, x2: F32) + array A = [3] U32 + enum E { A, B } + struct S { x: U32 } + + port P1( + x1: U32, + x2: F32, + x3: bool, + x4: string, + x5: A, + x6: E, + x7: S + ) port P2(x: U32) -> U32 port P3(x: F32) -> F32 + port P4(x: bool) -> bool + port P5(x: string) -> string + port P6(x: A) -> A + port P7(x: E) -> E + port P8(x: S) -> S passive component PassiveSender { output port p1: [2] P1 output port p2: [2] P2 output port p3: [2] P3 + output port p4: [2] P4 + output port p5: [2] P5 + output port p6: [2] P6 + output port p7: [2] P7 + output port p8: [2] P8 } @@ -17,6 +39,11 @@ module M { sync input port p1: [2] P1 sync input port p2: [2] P2 sync input port p3: [2] P3 + sync input port p4: [2] P4 + sync input port p5: [2] P5 + sync input port p6: [2] P6 + sync input port p7: [2] P7 + sync input port p8: [2] P8 } @@ -30,14 +57,29 @@ module M { connections C { - passiveSender.p1 -> passiveReceiver.p1 - passiveSender.p1 -> passiveReceiver.p1 + passiveSender.p1[0] -> passiveReceiver.p1[1] + passiveSender.p1[1] -> passiveReceiver.p1[0] passiveSender.p2[0] -> passiveReceiver.p2[1] passiveSender.p2[1] -> passiveReceiver.p2[0] - passiveSender.p3 -> passiveReceiver.p3 - passiveSender.p3 -> passiveReceiver.p3 + passiveSender.p3[0] -> passiveReceiver.p3[0] + passiveSender.p3[1] -> passiveReceiver.p3[1] + + passiveSender.p4 -> passiveReceiver.p4 + passiveSender.p4 -> passiveReceiver.p4 + + passiveSender.p5 -> passiveReceiver.p5 + passiveSender.p5 -> passiveReceiver.p5 + + passiveSender.p6 -> passiveReceiver.p6 + passiveSender.p6 -> passiveReceiver.p6 + + passiveSender.p7 -> passiveReceiver.p7 + passiveSender.p7 -> passiveReceiver.p7 + + passiveSender.p8 -> passiveReceiver.p8 + passiveSender.p8 -> passiveReceiver.p8 }