This is an automated email from the ASF dual-hosted git repository.

sruehl pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/plc4x.git

commit 8bb9121f37fd463086e7a509b91cfaf36aad125d
Author: Sebastian Rühl <[email protected]>
AuthorDate: Wed Aug 21 17:54:27 2024 +0200

    fix(plc4go/bacnet): ICouldBeRouterToNetwork
---
 plc4go/internal/bacnetip/comp.go                   |   6 +-
 plc4go/internal/bacnetip/npdu.go                   | 123 +++++++++++++++++----
 plc4go/internal/bacnetip/tests/state_machine.go    |  12 ++
 .../bacnetip/tests/test_npdu/test_codec_test.go    |  35 +++++-
 4 files changed, 150 insertions(+), 26 deletions(-)

diff --git a/plc4go/internal/bacnetip/comp.go b/plc4go/internal/bacnetip/comp.go
index 5978a94dd5..855ded48e3 100644
--- a/plc4go/internal/bacnetip/comp.go
+++ b/plc4go/internal/bacnetip/comp.go
@@ -122,8 +122,10 @@ const (
        ////
        // NPDU related keys
 
-       KWWirtnNetwork     = KnownKey("wirtnNetwork")
-       KWIartnNetworkList = KnownKey("iartnNetworkList")
+       KWWirtnNetwork           = KnownKey("wirtnNetwork")
+       KWIartnNetworkList       = KnownKey("iartnNetworkList")
+       KWIcbrtnNetwork          = KnownKey("icbrtnNetwork")
+       KWIcbrtnPerformanceIndex = KnownKey("icbrtnPerformanceIndex")
 )
 
 type MessageBridge struct {
diff --git a/plc4go/internal/bacnetip/npdu.go b/plc4go/internal/bacnetip/npdu.go
index e7d5f5842b..1ae53d0c38 100644
--- a/plc4go/internal/bacnetip/npdu.go
+++ b/plc4go/internal/bacnetip/npdu.go
@@ -342,17 +342,17 @@ type IAmRouterToNetwork struct {
 }
 
 func NewIAmRouterToNetwork(opts ...func(*IAmRouterToNetwork)) 
(*IAmRouterToNetwork, error) {
-       w := &IAmRouterToNetwork{}
+       i := &IAmRouterToNetwork{}
        for _, opt := range opts {
-               opt(w)
+               opt(i)
        }
-       w.NLMIAmRouterToNetwork = 
readWriteModel.NewNLMIAmRouterToNetwork(w.iartnNetworkList, 0)
-       npdu, err := NewNPDU(w.NLMIAmRouterToNetwork, nil)
+       i.NLMIAmRouterToNetwork = 
readWriteModel.NewNLMIAmRouterToNetwork(i.iartnNetworkList, 0)
+       npdu, err := NewNPDU(i.NLMIAmRouterToNetwork, nil)
        if err != nil {
                return nil, errors.Wrap(err, "error creating NPDU")
        }
-       w._NPDU = npdu.(*_NPDU)
-       return w, nil
+       i._NPDU = npdu.(*_NPDU)
+       return i, nil
 }
 
 func WithIAmRouterToNetworkNetworkList(iartnNetworkList ...uint16) 
func(*IAmRouterToNetwork) {
@@ -361,41 +361,41 @@ func WithIAmRouterToNetworkNetworkList(iartnNetworkList 
...uint16) func(*IAmRout
        }
 }
 
-func (n *IAmRouterToNetwork) GetIartnNetworkList() []uint16 {
-       return n.iartnNetworkList
+func (i *IAmRouterToNetwork) GetIartnNetworkList() []uint16 {
+       return i.iartnNetworkList
 }
 
-func (n *IAmRouterToNetwork) Encode(npdu Arg) error {
+func (i *IAmRouterToNetwork) Encode(npdu Arg) error {
        switch npdu := npdu.(type) {
        case NPDU:
-               if err := npdu.Update(n); err != nil {
+               if err := npdu.Update(i); err != nil {
                        return errors.Wrap(err, "error updating _NPCI")
                }
-               for _, net := range n.iartnNetworkList {
+               for _, net := range i.iartnNetworkList {
                        npdu.PutShort(int16(net))
                }
-               npdu.setNPDU(n.npdu)
-               npdu.setNLM(n.nlm)
-               npdu.setAPDU(n.apdu)
+               npdu.setNPDU(i.npdu)
+               npdu.setNLM(i.nlm)
+               npdu.setAPDU(i.apdu)
                return nil
        default:
                return errors.Errorf("invalid NPDU type %T", npdu)
        }
 }
 
-func (n *IAmRouterToNetwork) Decode(npdu Arg) error {
+func (i *IAmRouterToNetwork) Decode(npdu Arg) error {
        switch npdu := npdu.(type) {
        case NPDU:
-               if err := n.Update(npdu); err != nil {
+               if err := i.Update(npdu); err != nil {
                        return errors.Wrap(err, "error updating _NPCI")
                }
                switch pduUserData := npdu.GetPDUUserData().(type) {
                case readWriteModel.NPDUExactly:
                        switch nlm := pduUserData.GetNlm().(type) {
                        case readWriteModel.NLMIAmRouterToNetworkExactly:
-                               n.setNLM(nlm)
-                               n.NLMIAmRouterToNetwork = nlm
-                               n.iartnNetworkList = 
nlm.GetDestinationNetworkAddresses()
+                               i.setNLM(nlm)
+                               i.NLMIAmRouterToNetwork = nlm
+                               i.iartnNetworkList = 
nlm.GetDestinationNetworkAddresses()
                        }
                }
                return nil
@@ -404,16 +404,93 @@ func (n *IAmRouterToNetwork) Decode(npdu Arg) error {
        }
 }
 
-func (n *IAmRouterToNetwork) String() string {
-       return fmt.Sprintf("IAmRouterToNetwork{%s, iartnNetworkList: %v}", 
n._NPDU, n.iartnNetworkList)
+func (i *IAmRouterToNetwork) String() string {
+       return fmt.Sprintf("IAmRouterToNetwork{%s, iartnNetworkList: %v}", 
i._NPDU, i.iartnNetworkList)
 }
 
 type ICouldBeRouterToNetwork struct {
        *_NPDU
+
+       icbrtnNetwork          uint16
+       icbrtnPerformanceIndex uint8
+
+       readWriteModel.NLMICouldBeRouterToNetwork
 }
 
-func NewICouldBeRouterToNetwork() (*ICouldBeRouterToNetwork, error) {
-       panic("implement me")
+func NewICouldBeRouterToNetwork(opts ...func(*ICouldBeRouterToNetwork)) 
(*ICouldBeRouterToNetwork, error) {
+       i := &ICouldBeRouterToNetwork{}
+       for _, opt := range opts {
+               opt(i)
+       }
+       i.NLMICouldBeRouterToNetwork = 
readWriteModel.NewNLMICouldBeRouterToNetwork(i.icbrtnNetwork, 
i.icbrtnPerformanceIndex, 0)
+       npdu, err := NewNPDU(i.NLMICouldBeRouterToNetwork, nil)
+       if err != nil {
+               return nil, errors.Wrap(err, "error creating NPDU")
+       }
+       i._NPDU = npdu.(*_NPDU)
+       return i, nil
+}
+
+func WithICouldBeRouterToNetworkNetwork(icbrtnNetwork uint16) 
func(*ICouldBeRouterToNetwork) {
+       return func(n *ICouldBeRouterToNetwork) {
+               n.icbrtnNetwork = icbrtnNetwork
+       }
+}
+func WithICouldBeRouterToNetworkPerformanceIndex(icbrtnPerformanceIndex uint8) 
func(*ICouldBeRouterToNetwork) {
+       return func(n *ICouldBeRouterToNetwork) {
+               n.icbrtnPerformanceIndex = icbrtnPerformanceIndex
+       }
+}
+
+func (n *ICouldBeRouterToNetwork) GeticbrtnNetwork() uint16 {
+       return n.icbrtnNetwork
+}
+
+func (n *ICouldBeRouterToNetwork) GetIcbrtnPerformanceIndex() uint8 {
+       return n.icbrtnPerformanceIndex
+}
+
+func (n *ICouldBeRouterToNetwork) Encode(npdu Arg) error {
+       switch npdu := npdu.(type) {
+       case NPDU:
+               if err := npdu.Update(n); err != nil {
+                       return errors.Wrap(err, "error updating _NPCI")
+               }
+               npdu.PutShort(int16(n.icbrtnNetwork))
+               npdu.Put(n.icbrtnPerformanceIndex)
+               npdu.setNPDU(n.npdu)
+               npdu.setNLM(n.nlm)
+               npdu.setAPDU(n.apdu)
+               return nil
+       default:
+               return errors.Errorf("invalid NPDU type %T", npdu)
+       }
+}
+
+func (n *ICouldBeRouterToNetwork) Decode(npdu Arg) error {
+       switch npdu := npdu.(type) {
+       case NPDU:
+               if err := n.Update(npdu); err != nil {
+                       return errors.Wrap(err, "error updating _NPCI")
+               }
+               switch pduUserData := npdu.GetPDUUserData().(type) {
+               case readWriteModel.NPDUExactly:
+                       switch nlm := pduUserData.GetNlm().(type) {
+                       case readWriteModel.NLMICouldBeRouterToNetworkExactly:
+                               n.setNLM(nlm)
+                               n.NLMICouldBeRouterToNetwork = nlm
+                               n.icbrtnNetwork = 
nlm.GetDestinationNetworkAddress()
+                               n.icbrtnPerformanceIndex = 
nlm.GetPerformanceIndex()
+                       }
+               }
+               return nil
+       default:
+               return errors.Errorf("invalid NPDU type %T", npdu)
+       }
+}
+
+func (n *ICouldBeRouterToNetwork) String() string {
+       return fmt.Sprintf("ICouldBeRouterToNetwork{%s, icbrtnNetwork: %v, 
icbrtnPerformanceIndex: %v}", n._NPDU, n.icbrtnNetwork, 
n.icbrtnPerformanceIndex)
 }
 
 type RejectMessageToNetwork struct {
diff --git a/plc4go/internal/bacnetip/tests/state_machine.go 
b/plc4go/internal/bacnetip/tests/state_machine.go
index 37fa005ee8..b0915769ca 100644
--- a/plc4go/internal/bacnetip/tests/state_machine.go
+++ b/plc4go/internal/bacnetip/tests/state_machine.go
@@ -173,6 +173,18 @@ func MatchPdu(localLog zerolog.Logger, pdu bacnetip.PDU, 
pduType any, pduAttrs m
                                return false
                        }
                        return slices.Equal(net, uint16s)
+               case bacnetip.KWIcbrtnNetwork:
+                       iamrtn, ok := pdu.(*bacnetip.ICouldBeRouterToNetwork)
+                       if !ok {
+                               return false
+                       }
+                       return iamrtn.GetDestinationNetworkAddress() == 
attrValue
+               case bacnetip.KWIcbrtnPerformanceIndex:
+                       iamrtn, ok := pdu.(*bacnetip.ICouldBeRouterToNetwork)
+                       if !ok {
+                               return false
+                       }
+                       return iamrtn.GetPerformanceIndex() == attrValue
                default:
                        panic("implement " + attrName)
                }
diff --git a/plc4go/internal/bacnetip/tests/test_npdu/test_codec_test.go 
b/plc4go/internal/bacnetip/tests/test_npdu/test_codec_test.go
index 7967781e36..d175dee519 100644
--- a/plc4go/internal/bacnetip/tests/test_npdu/test_codec_test.go
+++ b/plc4go/internal/bacnetip/tests/test_npdu/test_codec_test.go
@@ -47,6 +47,14 @@ func IAmRouterToNetwork(netList ...uint16) 
*bacnetip.IAmRouterToNetwork {
        return network
 }
 
+func ICouldBeRouterToNetwork(net uint16, perf uint8) 
*bacnetip.ICouldBeRouterToNetwork {
+       network, err := 
bacnetip.NewICouldBeRouterToNetwork(bacnetip.WithICouldBeRouterToNetworkNetwork(net),
 bacnetip.WithICouldBeRouterToNetworkPerformanceIndex(perf))
+       if err != nil {
+               panic(err)
+       }
+       return network
+}
+
 type TestNPDUCodecSuite struct {
        suite.Suite
 
@@ -174,7 +182,7 @@ func (suite *TestNPDUCodecSuite) TestIAMRouterToNetworks() 
{ // Test the Result
                parse, err := 
readWriteModel.NPDUParse(testutils.TestContext(suite.T()), pduBytes, 
uint16(len(pduBytes)))
                suite.Assert().NoError(err)
                if parse != nil {
-                       suite.T().Log(parse.String())
+                       suite.T().Log("\n" + parse.String())
                }
        }
 
@@ -188,6 +196,31 @@ func (suite *TestNPDUCodecSuite) TestIAMRouterToNetworks() 
{ // Test the Result
        err = 
suite.Confirmation(bacnetip.NewArgs(&bacnetip.IAmRouterToNetwork{}), 
bacnetip.NewKWArgs(bacnetip.KWIartnNetworkList, networkList))
 }
 
+func (suite *TestNPDUCodecSuite) TestICouldBeRouterToNetworks() { // Test the 
Result encoding and decoding.
+       // Request successful
+       pduBytes, err := bacnetip.Xtob(
+               "01.80" + // version, network layer message
+                       "02 0001 02", // message type, network, performance
+       )
+       suite.Require().NoError(err)
+       { // Parse with plc4x parser to validate
+               parse, err := 
readWriteModel.NPDUParse(testutils.TestContext(suite.T()), pduBytes, 
uint16(len(pduBytes)))
+               suite.Assert().NoError(err)
+               if parse != nil {
+                       suite.T().Log("\n" + parse.String())
+               }
+       }
+
+       err = suite.Request(bacnetip.NewArgs(ICouldBeRouterToNetwork(1, 2)), 
bacnetip.NoKWArgs)
+       suite.Assert().NoError(err)
+       err = suite.Indication(bacnetip.NoArgs, 
bacnetip.NewKWArgs(bacnetip.KWPDUData, pduBytes))
+       suite.Assert().NoError(err)
+
+       err = 
suite.Response(bacnetip.NewArgs(bacnetip.NewPDU(&bacnetip.MessageBridge{Bytes: 
pduBytes})), bacnetip.NoKWArgs)
+       suite.Assert().NoError(err)
+       err = 
suite.Confirmation(bacnetip.NewArgs(&bacnetip.ICouldBeRouterToNetwork{}), 
bacnetip.NewKWArgs(bacnetip.KWIcbrtnNetwork, uint16(1), 
bacnetip.KWIcbrtnPerformanceIndex, uint8(2)))
+}
+
 func TestNPDUCodec(t *testing.T) {
        suite.Run(t, new(TestNPDUCodecSuite))
 }

Reply via email to