You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@plc4x.apache.org by sr...@apache.org on 2024/08/29 06:39:03 UTC
(plc4x) 01/02: test(plc4go/bacnetip): net test 1 finished
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 0ccd3a4e411da6baff62805a63af130da2aa0410
Author: Sebastian Rühl <sr...@apache.org>
AuthorDate: Thu Aug 29 07:36:56 2024 +0200
test(plc4go/bacnetip): net test 1 finished
---
plc4go/internal/bacnetip/comp.go | 7 +
.../netservice_NetworkServiceAccessPoint.go | 6 +-
.../bacnetip/netservice_RouterInfoCache.go | 24 +-
.../bacnetip/tests/test_network/test_net_1_test.go | 259 +++++++++++++--------
4 files changed, 194 insertions(+), 102 deletions(-)
diff --git a/plc4go/internal/bacnetip/comp.go b/plc4go/internal/bacnetip/comp.go
index 31f56887f9..c7573e4a38 100644
--- a/plc4go/internal/bacnetip/comp.go
+++ b/plc4go/internal/bacnetip/comp.go
@@ -289,6 +289,13 @@ type NillableKey[T any] struct {
isNil bool
}
+func (n NillableKey[T]) String() string {
+ if n.isNil {
+ return "nil"
+ }
+ return fmt.Sprintf("%v", n.value)
+}
+
// NK creates a new NillableKey of type K
func NK[T any, K NillableKey[T]](value *T) K {
var _nk NillableKey[T]
diff --git a/plc4go/internal/bacnetip/netservice_NetworkServiceAccessPoint.go b/plc4go/internal/bacnetip/netservice_NetworkServiceAccessPoint.go
index d70a1d6bdc..72d3370dc0 100644
--- a/plc4go/internal/bacnetip/netservice_NetworkServiceAccessPoint.go
+++ b/plc4go/internal/bacnetip/netservice_NetworkServiceAccessPoint.go
@@ -162,7 +162,7 @@ func (n *NetworkServiceAccessPoint) Bind(server Server, net *uint16, address *Ad
}
// UpdateRouterReference Update references to routers.
-func (n *NetworkServiceAccessPoint) UpdateRouterReference(snet *uint16, address, dnets any) error {
+func (n *NetworkServiceAccessPoint) UpdateRouterReference(snet *uint16, address *Address, dnets []uint16) error {
n.log.Debug().
Interface("snet", snet).
Interface("address", address).
@@ -176,11 +176,11 @@ func (n *NetworkServiceAccessPoint) UpdateRouterReference(snet *uint16, address,
}
// pass this along to the cache
- return n.routerInfoCache.UpdateRouterInfo(nk(snet), address, dnets)
+ return n.routerInfoCache.UpdateRouterInfo(nk(snet), address, dnets, nil)
}
// DeleteRouterReference Delete references to routers/networks.
-func (n *NetworkServiceAccessPoint) DeleteRouterReference(snet *uint16, address, dnets any) error {
+func (n *NetworkServiceAccessPoint) DeleteRouterReference(snet *uint16, address *Address, dnets []uint16) error {
n.log.Debug().
Interface("snet", snet).
Interface("address", address).
diff --git a/plc4go/internal/bacnetip/netservice_RouterInfoCache.go b/plc4go/internal/bacnetip/netservice_RouterInfoCache.go
index 5324185fac..16cb7d3e57 100644
--- a/plc4go/internal/bacnetip/netservice_RouterInfoCache.go
+++ b/plc4go/internal/bacnetip/netservice_RouterInfoCache.go
@@ -81,12 +81,28 @@ func NewRouterInfoCache(localLog zerolog.Logger) *RouterInfoCache {
}
}
-func (n *RouterInfoCache) GetRouterInfo(netKey, netKey) *RouterInfo {
- panic("not implemented yet")
- return nil
+func (n *RouterInfoCache) GetRouterInfo(snet, dnet netKey) *RouterInfo {
+ n.log.Debug().Stringer("snet", snet).Stringer("dnet", dnet).Msg("GetRouterInfo")
+
+ // return the network and address
+ routerInfo, _ := n.pathInfo[snetDnetTuple{snet, dnet}]
+ return routerInfo
}
-func (n *RouterInfoCache) UpdateRouterInfo(netKey, any, any) error {
+func (n *RouterInfoCache) UpdateRouterInfo(snet netKey, address *Address, dnets []uint16, status *RouterStatus) error {
+ n.log.Debug().Stringer("snet", snet).Stringer("dnet", address).Uints16("dnets", dnets).Msg("UpdateRouterInfo")
+
+ existingRouterInfo, _ := n.routers[snet] // TODO: what is happening here with the address
+
+ var otherRouters []*RouterInfo
+ for _, dnet := range dnets {
+ otherRouter, _ := n.pathInfo[snetDnetTuple{snet, nk(&dnet)}]
+ if otherRouter != nil && otherRouter != existingRouterInfo {
+ otherRouters = append(otherRouters, otherRouter)
+ }
+ }
+
+ // TODO: finish
panic("not implemented yet")
return nil
}
diff --git a/plc4go/internal/bacnetip/tests/test_network/test_net_1_test.go b/plc4go/internal/bacnetip/tests/test_network/test_net_1_test.go
index 9739ca6a76..9213dfecff 100644
--- a/plc4go/internal/bacnetip/tests/test_network/test_net_1_test.go
+++ b/plc4go/internal/bacnetip/tests/test_network/test_net_1_test.go
@@ -27,7 +27,7 @@ import (
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
- "github.com/apache/plc4x/plc4go/internal/bacnetip"
+ . "github.com/apache/plc4x/plc4go/internal/bacnetip"
"github.com/apache/plc4x/plc4go/internal/bacnetip/tests"
"github.com/apache/plc4x/plc4go/spi/testutils"
)
@@ -35,13 +35,13 @@ import (
type TNetwork1 struct {
*tests.StateMachineGroup
- vlan1 *bacnetip.Network
+ vlan1 *Network
iut *RouterNode
td *NetworkLayerStateMachine
sniffer1 *SnifferStateMachine
- vlan2 *bacnetip.Network
+ vlan2 *Network
sniffer2 *SnifferStateMachine
- vlan3 *bacnetip.Network
+ vlan3 *Network
sniffer3 *SnifferStateMachine
t *testing.T
@@ -67,7 +67,7 @@ func NewTNetwork1(t *testing.T) *TNetwork1 {
require.NoError(t, err)
// make a little LAN
- tn.vlan1 = bacnetip.NewNetwork(localLog, bacnetip.WithNetworkName("vlan1"), bacnetip.WithNetworkBroadcastAddress(bacnetip.NewLocalBroadcast(nil)))
+ tn.vlan1 = NewNetwork(localLog, WithNetworkName("vlan1"), WithNetworkBroadcastAddress(NewLocalBroadcast(nil)))
// Test devices
tn.td, err = NewNetworkLayerStateMachine(localLog, "1", tn.vlan1)
@@ -84,7 +84,7 @@ func NewTNetwork1(t *testing.T) *TNetwork1 {
require.NoError(t, err)
// make another little LAN
- tn.vlan2 = bacnetip.NewNetwork(tn.log, bacnetip.WithNetworkName("vlan2"), bacnetip.WithNetworkBroadcastAddress(bacnetip.NewLocalBroadcast(nil)))
+ tn.vlan2 = NewNetwork(tn.log, WithNetworkName("vlan2"), WithNetworkBroadcastAddress(NewLocalBroadcast(nil)))
// sniffer node
tn.sniffer2, err = NewSnifferStateMachine(localLog, "4", tn.vlan2)
@@ -96,7 +96,7 @@ func NewTNetwork1(t *testing.T) *TNetwork1 {
require.NoError(t, err)
// make another little LAN
- tn.vlan3 = bacnetip.NewNetwork(tn.log, bacnetip.WithNetworkName("vlan3"), bacnetip.WithNetworkBroadcastAddress(bacnetip.NewLocalBroadcast(nil)))
+ tn.vlan3 = NewNetwork(tn.log, WithNetworkName("vlan3"), WithNetworkBroadcastAddress(NewLocalBroadcast(nil)))
// sniffer node
tn.sniffer3, err = NewSnifferStateMachine(localLog, "6", tn.vlan2)
@@ -133,97 +133,166 @@ func (t *TNetwork1) Run(timeLimit time.Duration) {
assert.False(t.t, failed)
}
-func TestSimple1(t *testing.T) {
- tests.ExclusiveGlobalTimeMachine(t)
+func TestNet1(t *testing.T) {
+ t.Run("TestSimple1", func(t *testing.T) {
+ tests.ExclusiveGlobalTimeMachine(t)
- t.Run("testIdle", func(t *testing.T) {
- // create a network
- tnet := NewTNetwork1(t)
+ t.Run("testIdle", func(t *testing.T) {
+ // create a network
+ tnet := NewTNetwork1(t)
- // all start states are successful
- tnet.td.GetStartState().Success("")
- tnet.sniffer1.GetStartState().Success("")
- tnet.sniffer2.GetStartState().Success("")
- tnet.sniffer3.GetStartState().Success("")
+ // all start states are successful
+ tnet.td.GetStartState().Success("")
+ tnet.sniffer1.GetStartState().Success("")
+ tnet.sniffer2.GetStartState().Success("")
+ tnet.sniffer3.GetStartState().Success("")
- // run the group
- tnet.Run(0)
+ // run the group
+ tnet.Run(0)
+ })
})
-}
-
-func TestWhoIsRouterToNetwork(t *testing.T) {
- tests.ExclusiveGlobalTimeMachine(t)
-
- t.Run("test_01", func(t *testing.T) {
- //Test broadcast for any router.
- // create a network
- tnet := NewTNetwork1(t)
-
- // test device sends request, sees response
- whois, err := bacnetip.NewWhoIsRouterToNetwork()
- require.NoError(t, err)
- whois.SetPDUDestination(bacnetip.NewLocalBroadcast(nil)) // TODO: upstream does this inline
- tnet.td.GetStartState().Doc("1-1-0").
- Send(whois, nil).Doc("1-1-1").
- Receive(bacnetip.NewArgs((*bacnetip.IAmRouterToNetwork)(nil)), bacnetip.NewKWArgs(bacnetip.KWIartnNetworkList, []uint16{2, 3})).Doc("1-1-2").
- Success("")
-
- // sniffer on network 1 sees the request and the response
- tnet.sniffer1.GetStartState().Doc("1-2-0").
- Receive(bacnetip.NewArgs((bacnetip.PDU)(nil)),
- bacnetip.NewKWArgs(bacnetip.KWPDUData, xtob(
- "01.80"+ //version, network layer
- "00", //message type, no network
- ),
- ),
- ).Doc("1-2-1").
- Receive(bacnetip.NewArgs((bacnetip.PDU)(nil)),
- bacnetip.NewKWArgs(bacnetip.KWPDUData, xtob(
- "01.80"+ //version, network layer
- "01 0002 0003", //message type and network list
- ),
- ),
- ).Doc("1-2-2").
- Success("")
-
- // nothing received on network 2
- tnet.sniffer2.GetStartState().Doc("1-3-0").
- Timeout(3*time.Second, nil).Doc("1-3-1").
- Success("")
-
- // nothing received on network 3
- tnet.sniffer3.GetStartState().Doc("1-4-0").
- Timeout(3*time.Second, nil).Doc("1-4-1").
- Success("")
-
- // run the group
- tnet.Run(0)
- })
- t.Run("test_02", func(t *testing.T) {
- //Test broadcast for existing router.
- // create a network
- tnet := NewTNetwork1(t)
-
- // test device sends request, sees response
- whois, err := bacnetip.NewWhoIsRouterToNetwork(bacnetip.WithWhoIsRouterToNetworkNet(2))
- require.NoError(t, err)
- whois.SetPDUDestination(bacnetip.NewLocalBroadcast(nil)) // TODO: upstream does this inline
- tnet.td.GetStartState().Doc("2-1-0").
- Send(whois, nil).Doc("2-1-1").
- Receive(bacnetip.NewArgs((*bacnetip.IAmRouterToNetwork)(nil)), bacnetip.NewKWArgs(bacnetip.KWIartnNetworkList, []uint16{2})).Doc("2-1-2").
- Success("")
-
- // sniffer on network 1 sees the request and the response
- tnet.sniffer1.GetStartState().Success("")
-
- // nothing received on network 2
- tnet.sniffer2.GetStartState().Doc("2-2-0").
- Timeout(3*time.Second, nil).Doc("2-2-1").
- Success("")
-
- tnet.sniffer3.GetStartState().Success("")
-
- // run the group
- tnet.Run(0)
+ t.Run("TestWhoIsRouterToNetwork", func(t *testing.T) {
+ t.Run("test_01", func(t *testing.T) {
+ //Test broadcast for any router.
+ tests.ExclusiveGlobalTimeMachine(t)
+
+ // create a network
+ tnet := NewTNetwork1(t)
+
+ // test device sends request, sees response
+ whois, err := NewWhoIsRouterToNetwork()
+ require.NoError(t, err)
+ whois.SetPDUDestination(NewLocalBroadcast(nil)) // TODO: upstream does this inline
+ tnet.td.GetStartState().Doc("1-1-0").
+ Send(whois, nil).Doc("1-1-1").
+ Receive(NewArgs((*IAmRouterToNetwork)(nil)), NewKWArgs(KWIartnNetworkList, []uint16{2, 3})).Doc("1-1-2").
+ Success("")
+
+ // sniffer on network 1 sees the request and the response
+ tnet.sniffer1.GetStartState().Doc("1-2-0").
+ Receive(NewArgs((PDU)(nil)),
+ NewKWArgs(KWPDUData, xtob(
+ "01.80"+ //version, network layer
+ "00", //message type, no network
+ ),
+ ),
+ ).Doc("1-2-1").
+ Receive(NewArgs((PDU)(nil)),
+ NewKWArgs(KWPDUData, xtob(
+ "01.80"+ //version, network layer
+ "01 0002 0003", //message type and network list
+ ),
+ ),
+ ).Doc("1-2-2").
+ Success("")
+
+ // nothing received on network 2
+ tnet.sniffer2.GetStartState().Doc("1-3-0").
+ Timeout(3*time.Second, nil).Doc("1-3-1").
+ Success("")
+
+ // nothing received on network 3
+ tnet.sniffer3.GetStartState().Doc("1-4-0").
+ Timeout(3*time.Second, nil).Doc("1-4-1").
+ Success("")
+
+ // run the group
+ tnet.Run(0)
+ })
+ t.Run("test_02", func(t *testing.T) {
+ //Test broadcast for existing router.
+ tests.ExclusiveGlobalTimeMachine(t)
+ // create a network
+ tnet := NewTNetwork1(t)
+
+ // test device sends request, sees response
+ whois, err := NewWhoIsRouterToNetwork(WithWhoIsRouterToNetworkNet(2))
+ require.NoError(t, err)
+ whois.SetPDUDestination(NewLocalBroadcast(nil)) // TODO: upstream does this inline
+ tnet.td.GetStartState().Doc("2-1-0").
+ Send(whois, nil).Doc("2-1-1").
+ Receive(NewArgs((*IAmRouterToNetwork)(nil)), NewKWArgs(KWIartnNetworkList, []uint16{2})).Doc("2-1-2").
+ Success("")
+
+ tnet.sniffer1.GetStartState().Success("")
+
+ // nothing received on network 2
+ tnet.sniffer2.GetStartState().Doc("2-2-0").
+ Timeout(3*time.Second, nil).Doc("2-2-1").
+ Success("")
+
+ tnet.sniffer3.GetStartState().Success("")
+
+ // run the group
+ tnet.Run(0)
+ })
+ t.Run("test_03", func(t *testing.T) {
+ //Test broadcast for non-existing router.
+ tests.ExclusiveGlobalTimeMachine(t)
+ // create a network
+ tnet := NewTNetwork1(t)
+
+ // test device sends request, sees response
+ whois, err := NewWhoIsRouterToNetwork(WithWhoIsRouterToNetworkNet(4))
+ require.NoError(t, err)
+ whois.SetPDUDestination(NewLocalBroadcast(nil)) // TODO: upstream does this inline
+ tnet.td.GetStartState().Doc("3-1-0").
+ Send(whois, nil).Doc("3-1-1").
+ Timeout(3*time.Second, nil).Doc("3-1-2").
+ Success("")
+
+ // sniffer on network 1 sees the request and the response
+ tnet.sniffer1.GetStartState().Doc("3-2-0").
+ Receive(NewArgs((PDU)(nil)),
+ NewKWArgs(KWPDUData, xtob(
+ "01.80"+ //version, network layer
+ "00 0004", //message type, and network
+ )),
+ ).Doc("3-2-1").
+ Success("")
+
+ // sniffer on network 2 sees request forwarded by router
+ tnet.sniffer2.GetStartState().Doc("3-3-0").
+ Receive(NewArgs((PDU)(nil)),
+ NewKWArgs(KWPDUData, xtob(
+ "01.88"+ //version, network layer
+ "0001 01 01"+ // snet/slen/sadr
+ "00 0004", //message type, and network
+ )),
+ ).Doc("3-3-1").
+ Success("")
+
+ tnet.sniffer3.GetStartState().Success("")
+
+ // run the group
+ tnet.Run(0)
+ })
+ t.Run("test_04", func(t *testing.T) {
+ // Test broadcast for a router to the network it is on.
+ tests.ExclusiveGlobalTimeMachine(t)
+ // create a network
+ tnet := NewTNetwork1(t)
+
+ // test device sends request, sees response
+ whois, err := NewWhoIsRouterToNetwork(WithWhoIsRouterToNetworkNet(1))
+ require.NoError(t, err)
+ whois.SetPDUDestination(NewLocalBroadcast(nil)) // TODO: upstream does this inline
+ tnet.td.GetStartState().Doc("4-1-0").
+ Send(whois, nil).Doc("4-1-1").
+ Timeout(3*time.Second, nil).Doc("4-1-2").
+ Success("")
+
+ tnet.sniffer1.GetStartState().Success("")
+
+ // nothing received on network 2
+ tnet.sniffer2.GetStartState().Doc("4-3-0").
+ Timeout(3*time.Second, nil).Doc("4-2-1").
+ Success("")
+
+ tnet.sniffer3.GetStartState().Success("")
+
+ // run the group
+ tnet.Run(0)
+ })
})
}