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 2025/11/20 13:28:28 UTC
(plc4x) 01/08: test(plc4go): use sync test
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 009fbdd0aa6c5e30091c26729bb25fcefa6da640
Author: Sebastian Rühl <sr...@apache.org>
AuthorDate: Thu Nov 20 12:00:49 2025 +0100
test(plc4go): use sync test
---
.../bacgopes/tests/test_bvll/test_foreign_test.go | 373 +++++++++++----------
.../bacgopes/tests/test_network/test_net_2_test.go | 263 ++++++++-------
plc4go/internal/cbus/Browser_test.go | 33 +-
plc4go/internal/cbus/Connection_test.go | 35 +-
plc4go/internal/cbus/MessageCodec_test.go | 251 +++++++-------
plc4go/spi/testutils/ParserSerializerTestRunner.go | 9 +-
6 files changed, 500 insertions(+), 464 deletions(-)
diff --git a/plc4go/internal/bacnetip/bacgopes/tests/test_bvll/test_foreign_test.go b/plc4go/internal/bacnetip/bacgopes/tests/test_bvll/test_foreign_test.go
index 2514426265..e620cf0f09 100644
--- a/plc4go/internal/bacnetip/bacgopes/tests/test_bvll/test_foreign_test.go
+++ b/plc4go/internal/bacnetip/bacgopes/tests/test_bvll/test_foreign_test.go
@@ -21,6 +21,7 @@ package test_bvll
import (
"testing"
+ "testing/synctest"
"time"
"github.com/rs/zerolog"
@@ -121,197 +122,207 @@ func (t *TFNetwork) Run(timeLimit time.Duration) {
func TestForeign(t *testing.T) {
t.Run("test_idle", func(t *testing.T) { //Test an idle network, nothing happens is success.
- ExclusiveGlobalTimeMachine(t)
+ synctest.Test(t, func(t *testing.T) {
+ ExclusiveGlobalTimeMachine(t)
- tnet := NewTFNetwork(t)
+ tnet := NewTFNetwork(t)
- // all start state are successful
- tnet.fd.GetStartState().Success("")
- tnet.bbmd.GetStartState().Success("")
+ // all start state are successful
+ tnet.fd.GetStartState().Success("")
+ tnet.bbmd.GetStartState().Success("")
- // run the group
- tnet.Run(0)
+ // run the group
+ tnet.Run(0)
+ })
})
t.Run("test_registration", func(t *testing.T) {
- ExclusiveGlobalTimeMachine(t)
- testingLogger := testutils.ProduceTestingLogger(t)
-
- // create a network
- tnet := NewTFNetwork(t)
-
- // tell the B/IP layer of the foreign device to register
- tnet.fd.GetStartState().
- Call(func(args Args, _ KWArgs) error {
- return tnet.fd.bip.Register(args[0].(*Address), args[1].(uint16))
- }, NA(tnet.bbmd.address, uint16(30)), NoKWArgs()).
- Success("")
-
- // remote sniffer node
- remoteSniffer, err := NewSnifferStateMachine(testingLogger, "192.168.6.254/24", tnet.vlan6)
- require.NoError(t, err)
- tnet.Append(remoteSniffer)
-
- // sniffer traffic
- remoteSniffer.GetStartState().Doc("1-1-0").
- Receive(NA((*RegisterForeignDevice)(nil)), NoKWArgs()).Doc("1-1-1").
- Receive(NA((*Result)(nil)), NoKWArgs()).Doc("1-1-2").
- SetEvent("fd-registered").Doc("1-1-3").
- Success("")
-
- // the bbmd is idle
- tnet.bbmd.GetStartState().Success("")
-
- // home snooper node
- homeSnooper, err := NewBIPStateMachine(testingLogger, "192.168.5.2/24", tnet.vlan5)
- tnet.Append(homeSnooper)
-
- // snooper will read foreign device table
- homeSnooper.GetStartState().Doc("1-2-0").
- WaitEvent("fd-registered", nil).Doc("1-2-1").
- Send(quick.ReadForeignDeviceTable(tnet.bbmd.address), nil).Doc("1-2-2").
- Receive(NA((*ReadForeignDeviceTableAck)(nil)), NoKWArgs()).Doc("1-2-3").
- Success("")
-
- // home sniffer node
- homeSniffer, err := NewSnifferStateMachine(testingLogger, "192.168.5.254/24", tnet.vlan5)
- require.NoError(t, err)
- tnet.Append(homeSniffer)
-
- // sniffer traffic
- homeSniffer.GetStartState().Doc("1-3-0").
- Receive(NA((*RegisterForeignDevice)(nil)), NoKWArgs()).Doc("1-3-1").
- Receive(NA((*Result)(nil)), NoKWArgs()).Doc("1-3-2").
- Receive(NA((*ReadForeignDeviceTable)(nil)), NoKWArgs()).Doc("1-3-3").
- Receive(NA((*ReadForeignDeviceTableAck)(nil)), NoKWArgs()).Doc("1-3-4").
- Success("")
-
- // run the group
- tnet.Run(0)
+ synctest.Test(t, func(t *testing.T) {
+ ExclusiveGlobalTimeMachine(t)
+ testingLogger := testutils.ProduceTestingLogger(t)
+
+ // create a network
+ tnet := NewTFNetwork(t)
+
+ // tell the B/IP layer of the foreign device to register
+ tnet.fd.GetStartState().
+ Call(func(args Args, _ KWArgs) error {
+ return tnet.fd.bip.Register(args[0].(*Address), args[1].(uint16))
+ }, NA(tnet.bbmd.address, uint16(30)), NoKWArgs()).
+ Success("")
+
+ // remote sniffer node
+ remoteSniffer, err := NewSnifferStateMachine(testingLogger, "192.168.6.254/24", tnet.vlan6)
+ require.NoError(t, err)
+ tnet.Append(remoteSniffer)
+
+ // sniffer traffic
+ remoteSniffer.GetStartState().Doc("1-1-0").
+ Receive(NA((*RegisterForeignDevice)(nil)), NoKWArgs()).Doc("1-1-1").
+ Receive(NA((*Result)(nil)), NoKWArgs()).Doc("1-1-2").
+ SetEvent("fd-registered").Doc("1-1-3").
+ Success("")
+
+ // the bbmd is idle
+ tnet.bbmd.GetStartState().Success("")
+
+ // home snooper node
+ homeSnooper, err := NewBIPStateMachine(testingLogger, "192.168.5.2/24", tnet.vlan5)
+ tnet.Append(homeSnooper)
+
+ // snooper will read foreign device table
+ homeSnooper.GetStartState().Doc("1-2-0").
+ WaitEvent("fd-registered", nil).Doc("1-2-1").
+ Send(quick.ReadForeignDeviceTable(tnet.bbmd.address), nil).Doc("1-2-2").
+ Receive(NA((*ReadForeignDeviceTableAck)(nil)), NoKWArgs()).Doc("1-2-3").
+ Success("")
+
+ // home sniffer node
+ homeSniffer, err := NewSnifferStateMachine(testingLogger, "192.168.5.254/24", tnet.vlan5)
+ require.NoError(t, err)
+ tnet.Append(homeSniffer)
+
+ // sniffer traffic
+ homeSniffer.GetStartState().Doc("1-3-0").
+ Receive(NA((*RegisterForeignDevice)(nil)), NoKWArgs()).Doc("1-3-1").
+ Receive(NA((*Result)(nil)), NoKWArgs()).Doc("1-3-2").
+ Receive(NA((*ReadForeignDeviceTable)(nil)), NoKWArgs()).Doc("1-3-3").
+ Receive(NA((*ReadForeignDeviceTableAck)(nil)), NoKWArgs()).Doc("1-3-4").
+ Success("")
+
+ // run the group
+ tnet.Run(0)
+ })
})
t.Run("test_refresh_registration", func(t *testing.T) {
- ExclusiveGlobalTimeMachine(t)
- testingLogger := testutils.ProduceTestingLogger(t)
-
- // create a network
- tnet := NewTFNetwork(t)
-
- // tell the B/IP layer of the foreign device to register
- tnet.fd.GetStartState().
- Call(func(args Args, _ KWArgs) error {
- return tnet.fd.bip.Register(args[0].(*Address), args[1].(uint16))
- }, NA(tnet.bbmd.address, uint16(10)), NoKWArgs()).
- Success("")
-
- // the bbmd is idle
- tnet.bbmd.GetStartState().Success("")
-
- // remote sniffer node
- remoteSniffer, err := NewSnifferStateMachine(testingLogger, "192.168.6.254/24", tnet.vlan6)
- require.NoError(t, err)
- tnet.Append(remoteSniffer)
-
- // sniffer traffic
- remoteSniffer.GetStartState().Doc("2-1-0").
- Receive(NA((*RegisterForeignDevice)(nil)), NoKWArgs()).Doc("2-1-1").
- Receive(NA((*Result)(nil)), NoKWArgs()).Doc("2-1-1").
- Receive(NA((*RegisterForeignDevice)(nil)), NoKWArgs()).Doc("2-1-3").
- Receive(NA((*Result)(nil)), NoKWArgs()).Doc("2-1-4").
- Success("")
-
- // run the group
- tnet.Run(0)
+ synctest.Test(t, func(t *testing.T) {
+ ExclusiveGlobalTimeMachine(t)
+ testingLogger := testutils.ProduceTestingLogger(t)
+
+ // create a network
+ tnet := NewTFNetwork(t)
+
+ // tell the B/IP layer of the foreign device to register
+ tnet.fd.GetStartState().
+ Call(func(args Args, _ KWArgs) error {
+ return tnet.fd.bip.Register(args[0].(*Address), args[1].(uint16))
+ }, NA(tnet.bbmd.address, uint16(10)), NoKWArgs()).
+ Success("")
+
+ // the bbmd is idle
+ tnet.bbmd.GetStartState().Success("")
+
+ // remote sniffer node
+ remoteSniffer, err := NewSnifferStateMachine(testingLogger, "192.168.6.254/24", tnet.vlan6)
+ require.NoError(t, err)
+ tnet.Append(remoteSniffer)
+
+ // sniffer traffic
+ remoteSniffer.GetStartState().Doc("2-1-0").
+ Receive(NA((*RegisterForeignDevice)(nil)), NoKWArgs()).Doc("2-1-1").
+ Receive(NA((*Result)(nil)), NoKWArgs()).Doc("2-1-1").
+ Receive(NA((*RegisterForeignDevice)(nil)), NoKWArgs()).Doc("2-1-3").
+ Receive(NA((*Result)(nil)), NoKWArgs()).Doc("2-1-4").
+ Success("")
+
+ // run the group
+ tnet.Run(0)
+ })
})
t.Run("test_unicast", func(t *testing.T) { //Test a unicast message from TD to IUT.
- ExclusiveGlobalTimeMachine(t)
- testingLogger := testutils.ProduceTestingLogger(t)
-
- tnet := NewTFNetwork(t)
-
- //make a PDU from node 1 to node 2
- pduData, err := Xtob("dead.beef")
- require.NoError(t, err)
- pdu := NewPDU(NA(pduData), NKW(KWCPCISource, tnet.fd.address, KWCPCIDestination, tnet.bbmd.address))
- t.Logf(" - pdu: %s", pdu)
-
- // register, wait for ack, send some beef
- tnet.fd.GetStartState().Doc("3-1-0").
- Call(func(args Args, _ KWArgs) error {
- return tnet.fd.bip.Register(args[0].(*Address), args[1].(uint16))
- }, NA(tnet.bbmd.address, uint16(60)), NoKWArgs()).Doc("3-1-1").
- WaitEvent("3-registered", nil).Doc("3-1-2").
- Send(pdu, nil).Doc("3-1-3").
- Success("")
-
- // the bbmd is happy when it gets the pdu
- tnet.bbmd.GetStartState().
- Receive(NA((PDU)(nil)), NKW(KWCPCISource, tnet.fd.address, KWTestPDUData, pduData)).
- Success("")
-
- // remote sniffer node
- remoteSniffer, err := NewSnifferStateMachine(testingLogger, "192.168.6.254/24", tnet.vlan6)
- require.NoError(t, err)
- tnet.Append(remoteSniffer)
-
- // sniffer traffic
- remoteSniffer.GetStartState().Doc("3-2-0").
- Receive(NA((*RegisterForeignDevice)(nil)), NoKWArgs()).Doc("3-2-1").
- Receive(NA((*Result)(nil)), NoKWArgs()).Doc("3-2-2").
- SetEvent("3-registered").Doc("3-2-3").
- Receive(NA((*OriginalUnicastNPDU)(nil)), NoKWArgs()).Doc("3-2-4").
- Success("")
-
- // run the group
- tnet.Run(0)
+ synctest.Test(t, func(t *testing.T) {
+ ExclusiveGlobalTimeMachine(t)
+ testingLogger := testutils.ProduceTestingLogger(t)
+
+ tnet := NewTFNetwork(t)
+
+ //make a PDU from node 1 to node 2
+ pduData, err := Xtob("dead.beef")
+ require.NoError(t, err)
+ pdu := NewPDU(NA(pduData), NKW(KWCPCISource, tnet.fd.address, KWCPCIDestination, tnet.bbmd.address))
+ t.Logf(" - pdu: %s", pdu)
+
+ // register, wait for ack, send some beef
+ tnet.fd.GetStartState().Doc("3-1-0").
+ Call(func(args Args, _ KWArgs) error {
+ return tnet.fd.bip.Register(args[0].(*Address), args[1].(uint16))
+ }, NA(tnet.bbmd.address, uint16(60)), NoKWArgs()).Doc("3-1-1").
+ WaitEvent("3-registered", nil).Doc("3-1-2").
+ Send(pdu, nil).Doc("3-1-3").
+ Success("")
+
+ // the bbmd is happy when it gets the pdu
+ tnet.bbmd.GetStartState().
+ Receive(NA((PDU)(nil)), NKW(KWCPCISource, tnet.fd.address, KWTestPDUData, pduData)).
+ Success("")
+
+ // remote sniffer node
+ remoteSniffer, err := NewSnifferStateMachine(testingLogger, "192.168.6.254/24", tnet.vlan6)
+ require.NoError(t, err)
+ tnet.Append(remoteSniffer)
+
+ // sniffer traffic
+ remoteSniffer.GetStartState().Doc("3-2-0").
+ Receive(NA((*RegisterForeignDevice)(nil)), NoKWArgs()).Doc("3-2-1").
+ Receive(NA((*Result)(nil)), NoKWArgs()).Doc("3-2-2").
+ SetEvent("3-registered").Doc("3-2-3").
+ Receive(NA((*OriginalUnicastNPDU)(nil)), NoKWArgs()).Doc("3-2-4").
+ Success("")
+
+ // run the group
+ tnet.Run(0)
+ })
})
t.Run("test_broadcast", func(t *testing.T) { //Test a broadcast message from TD to IUT.
- ExclusiveGlobalTimeMachine(t)
- testingLogger := testutils.ProduceTestingLogger(t)
-
- tnet := NewTFNetwork(t)
-
- //make a PDU from node 1 to node 2
- pduData, err := Xtob("dead.beef")
- require.NoError(t, err)
- pdu := NewPDU(NA(pduData), NKW(KWCPCISource, tnet.fd.address, KWCPCIDestination, NewLocalBroadcast(nil)))
- t.Logf("pdu: %v", pdu)
-
- // register, wait for ack, send some beef
- tnet.fd.GetStartState().Doc("4-1-0").
- Call(func(args Args, _ KWArgs) error {
- return tnet.fd.bip.Register(args[0].(*Address), args[1].(uint16))
- }, NA(tnet.bbmd.address, uint16(60)), NoKWArgs()).Doc("4-1-1").
- WaitEvent("4-registered", nil).Doc("4-1-2").
- Send(pdu, nil).Doc("4-1-3").
- Success("")
-
- // the bbmd is happy when it gets the pdu
- tnet.bbmd.GetStartState().
- Receive(NA((PDU)(nil)), NKW(KWCPCISource, tnet.fd.address, KWTestPDUData, pduData)).Doc("4-2-1").
- Success("")
-
- // home simple node
- homeNode, err := NewBIPSimpleStateMachine(testingLogger, "192.168.5.254/24", tnet.vlan5)
- require.NoError(t, err)
-
- // home node happy when getting the pdu, broadcast by the bbmd
- homeNode.GetStartState().Doc("4-3-0").
- Receive(NA((PDU)(nil)), NKW(KWCPCISource, tnet.fd.address, KWTestPDUData, pduData)).Doc("4-3-1").
- Success("")
-
- // remote sniffer node
- remoteSniffer, err := NewSnifferStateMachine(testingLogger, "192.168.6.254/24", tnet.vlan6)
- require.NoError(t, err)
- tnet.Append(remoteSniffer)
-
- // sniffer traffic
- remoteSniffer.GetStartState().Doc("4-4-0").
- Receive(NA((*RegisterForeignDevice)(nil)), NoKWArgs()).Doc("4-4-1").
- Receive(NA((*Result)(nil)), NoKWArgs()).Doc("4-4-2").
- SetEvent("4-registered").
- Receive(NA((*DistributeBroadcastToNetwork)(nil)), NoKWArgs()).Doc("4-4-3").
- Success("")
-
- // run the group
- tnet.Run(0)
+ synctest.Test(t, func(t *testing.T) {
+ ExclusiveGlobalTimeMachine(t)
+ testingLogger := testutils.ProduceTestingLogger(t)
+
+ tnet := NewTFNetwork(t)
+
+ //make a PDU from node 1 to node 2
+ pduData, err := Xtob("dead.beef")
+ require.NoError(t, err)
+ pdu := NewPDU(NA(pduData), NKW(KWCPCISource, tnet.fd.address, KWCPCIDestination, NewLocalBroadcast(nil)))
+ t.Logf("pdu: %v", pdu)
+
+ // register, wait for ack, send some beef
+ tnet.fd.GetStartState().Doc("4-1-0").
+ Call(func(args Args, _ KWArgs) error {
+ return tnet.fd.bip.Register(args[0].(*Address), args[1].(uint16))
+ }, NA(tnet.bbmd.address, uint16(60)), NoKWArgs()).Doc("4-1-1").
+ WaitEvent("4-registered", nil).Doc("4-1-2").
+ Send(pdu, nil).Doc("4-1-3").
+ Success("")
+
+ // the bbmd is happy when it gets the pdu
+ tnet.bbmd.GetStartState().
+ Receive(NA((PDU)(nil)), NKW(KWCPCISource, tnet.fd.address, KWTestPDUData, pduData)).Doc("4-2-1").
+ Success("")
+
+ // home simple node
+ homeNode, err := NewBIPSimpleStateMachine(testingLogger, "192.168.5.254/24", tnet.vlan5)
+ require.NoError(t, err)
+
+ // home node happy when getting the pdu, broadcast by the bbmd
+ homeNode.GetStartState().Doc("4-3-0").
+ Receive(NA((PDU)(nil)), NKW(KWCPCISource, tnet.fd.address, KWTestPDUData, pduData)).Doc("4-3-1").
+ Success("")
+
+ // remote sniffer node
+ remoteSniffer, err := NewSnifferStateMachine(testingLogger, "192.168.6.254/24", tnet.vlan6)
+ require.NoError(t, err)
+ tnet.Append(remoteSniffer)
+
+ // sniffer traffic
+ remoteSniffer.GetStartState().Doc("4-4-0").
+ Receive(NA((*RegisterForeignDevice)(nil)), NoKWArgs()).Doc("4-4-1").
+ Receive(NA((*Result)(nil)), NoKWArgs()).Doc("4-4-2").
+ SetEvent("4-registered").
+ Receive(NA((*DistributeBroadcastToNetwork)(nil)), NoKWArgs()).Doc("4-4-3").
+ Success("")
+
+ // run the group
+ tnet.Run(0)
+ })
})
}
diff --git a/plc4go/internal/bacnetip/bacgopes/tests/test_network/test_net_2_test.go b/plc4go/internal/bacnetip/bacgopes/tests/test_network/test_net_2_test.go
index b431add72a..80c693c212 100644
--- a/plc4go/internal/bacnetip/bacgopes/tests/test_network/test_net_2_test.go
+++ b/plc4go/internal/bacnetip/bacgopes/tests/test_network/test_net_2_test.go
@@ -21,6 +21,7 @@ package test_network
import (
"testing"
+ "testing/synctest"
"time"
"github.com/rs/zerolog"
@@ -150,141 +151,149 @@ func (t *TNetwork2) Run(timeLimit time.Duration) {
func TestNet2(t *testing.T) {
t.Run("TestSimple", func(t *testing.T) {
t.Run("testIdle", func(t *testing.T) {
- // create a network
- ExclusiveGlobalTimeMachine(t)
- tnet := NewTNetwork2(t)
-
- // 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)
+ synctest.Test(t, func(t *testing.T) {
+ // create a network
+ ExclusiveGlobalTimeMachine(t)
+ tnet := NewTNetwork2(t)
+
+ // 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)
+ })
})
})
t.Run("TestWhoIsRouterToNetwork", func(t *testing.T) {
t.Run("test_01", func(t *testing.T) {
- //Test broadcast for any router.
- ExclusiveGlobalTimeMachine(t)
-
- // create a network
- tnet := NewTNetwork2(t)
-
- // test device sends request, sees response
- whois, err := NewWhoIsRouterToNetwork(NoArgs, NewKWArgs(KWCPCIDestination, NewLocalBroadcast(nil)))
- require.NoError(t, err)
- tnet.td.GetStartState().Doc("1-1-0").
- Send(whois, nil).Doc("1-1-1").
- Receive(NA((*IAmRouterToNetwork)(nil)), NKW(KWIartnNetworkList, []uint16{2})).Doc("1-1-2").
- Success("")
-
- // sniffer on network 1 sees the request and the response
- tnet.sniffer1.GetStartState().Doc("1-2-0").
- Receive(NA(PDUMatcher),
- NKW(KWTestPDUData, xtob(
- "01.80"+ //version, network layer
- "00", //message type, no network
- )),
- ).Doc("1-2-1").
- Receive(NA(PDUMatcher),
- NKW(KWTestPDUData, xtob(
- "01.80"+ //version, network layer
- "01 0002", //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)
+ synctest.Test(t, func(t *testing.T) {
+ //Test broadcast for any router.
+ ExclusiveGlobalTimeMachine(t)
+
+ // create a network
+ tnet := NewTNetwork2(t)
+
+ // test device sends request, sees response
+ whois, err := NewWhoIsRouterToNetwork(NoArgs, NewKWArgs(KWCPCIDestination, NewLocalBroadcast(nil)))
+ require.NoError(t, err)
+ tnet.td.GetStartState().Doc("1-1-0").
+ Send(whois, nil).Doc("1-1-1").
+ Receive(NA((*IAmRouterToNetwork)(nil)), NKW(KWIartnNetworkList, []uint16{2})).Doc("1-1-2").
+ Success("")
+
+ // sniffer on network 1 sees the request and the response
+ tnet.sniffer1.GetStartState().Doc("1-2-0").
+ Receive(NA(PDUMatcher),
+ NKW(KWTestPDUData, xtob(
+ "01.80"+ //version, network layer
+ "00", //message type, no network
+ )),
+ ).Doc("1-2-1").
+ Receive(NA(PDUMatcher),
+ NKW(KWTestPDUData, xtob(
+ "01.80"+ //version, network layer
+ "01 0002", //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.
- ExclusiveGlobalTimeMachine(t)
- // create a network
- tnet := NewTNetwork2(t)
-
- // test device sends request, sees response
- whois, err := NewWhoIsRouterToNetwork(NoArgs, NewKWArgs(KWCPCIDestination, NewLocalBroadcast(nil)), WithWhoIsRouterToNetworkNet(2))
- require.NoError(t, err)
- tnet.td.GetStartState().Doc("2-1-0").
- Send(whois, nil).Doc("2-1-1").
- Receive(NA((*IAmRouterToNetwork)(nil)), NKW(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("")
-
- // nothing received on network 2
- tnet.sniffer3.GetStartState().Doc("2-3-0").
- Timeout(3*time.Second, nil).Doc("2-3-1").
- Success("")
-
- // run the group
- tnet.Run(0)
+ synctest.Test(t, func(t *testing.T) {
+ //Test broadcast for existing router.
+ ExclusiveGlobalTimeMachine(t)
+ // create a network
+ tnet := NewTNetwork2(t)
+
+ // test device sends request, sees response
+ whois, err := NewWhoIsRouterToNetwork(NoArgs, NewKWArgs(KWCPCIDestination, NewLocalBroadcast(nil)), WithWhoIsRouterToNetworkNet(2))
+ require.NoError(t, err)
+ tnet.td.GetStartState().Doc("2-1-0").
+ Send(whois, nil).Doc("2-1-1").
+ Receive(NA((*IAmRouterToNetwork)(nil)), NKW(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("")
+
+ // nothing received on network 2
+ tnet.sniffer3.GetStartState().Doc("2-3-0").
+ Timeout(3*time.Second, nil).Doc("2-3-1").
+ Success("")
+
+ // run the group
+ tnet.Run(0)
+ })
})
t.Run("test_03", func(t *testing.T) {
- //Test broadcast for non-existing router.
- ExclusiveGlobalTimeMachine(t)
- // create a network
- tnet := NewTNetwork2(t)
-
- // test device sends request, sees response
- whois, err := NewWhoIsRouterToNetwork(NoArgs, NewKWArgs(KWCPCIDestination, NewLocalBroadcast(nil)), WithWhoIsRouterToNetworkNet(4))
- require.NoError(t, err)
- 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(NA(PDUMatcher),
- NKW(KWTestPDUData, 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(NA(PDUMatcher),
- NKW(KWTestPDUData, 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().Doc("3-4-0").
- Receive(NA(PDUMatcher),
- NKW(KWTestPDUData, xtob(
- "01.88"+ //version, network layer
- "0001 01 01"+ // snet/slen/sadr
- "00 0004", //message type, and network
- )),
- ).Doc("3-4-1").
- Success("")
-
- // run the group
- tnet.Run(0)
+ synctest.Test(t, func(t *testing.T) {
+ //Test broadcast for non-existing router.
+ ExclusiveGlobalTimeMachine(t)
+ // create a network
+ tnet := NewTNetwork2(t)
+
+ // test device sends request, sees response
+ whois, err := NewWhoIsRouterToNetwork(NoArgs, NewKWArgs(KWCPCIDestination, NewLocalBroadcast(nil)), WithWhoIsRouterToNetworkNet(4))
+ require.NoError(t, err)
+ 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(NA(PDUMatcher),
+ NKW(KWTestPDUData, 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(NA(PDUMatcher),
+ NKW(KWTestPDUData, 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().Doc("3-4-0").
+ Receive(NA(PDUMatcher),
+ NKW(KWTestPDUData, xtob(
+ "01.88"+ //version, network layer
+ "0001 01 01"+ // snet/slen/sadr
+ "00 0004", //message type, and network
+ )),
+ ).Doc("3-4-1").
+ Success("")
+
+ // run the group
+ tnet.Run(0)
+ })
})
})
}
diff --git a/plc4go/internal/cbus/Browser_test.go b/plc4go/internal/cbus/Browser_test.go
index 699b2f0fd8..a762976fa8 100644
--- a/plc4go/internal/cbus/Browser_test.go
+++ b/plc4go/internal/cbus/Browser_test.go
@@ -27,6 +27,7 @@ import (
"sync"
"sync/atomic"
"testing"
+ "testing/synctest"
"time"
"github.com/pkg/errors"
@@ -613,21 +614,23 @@ func TestBrowser_getInstalledUnitAddressBytes(t *testing.T) {
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
- if tt.setup != nil {
- tt.setup(t, &tt.fields, &tt.args)
- }
- m := Browser{
- DefaultBrowser: tt.fields.DefaultBrowser,
- connection: tt.fields.connection,
- sequenceCounter: tt.fields.sequenceCounter,
- log: testutils.ProduceTestingLogger(t),
- }
- got, err := m.getInstalledUnitAddressBytes(tt.args.ctx)
- if !tt.wantErr(t, err, fmt.Sprintf("getInstalledUnitAddressBytes(%v)", tt.args.ctx)) {
- return
- }
- assert.Equalf(t, tt.want, got, "getInstalledUnitAddressBytes(%v)", tt.args.ctx)
- t.Log("Banananaaaa")
+ synctest.Test(t, func(t *testing.T) {
+ if tt.setup != nil {
+ tt.setup(t, &tt.fields, &tt.args)
+ }
+ m := Browser{
+ DefaultBrowser: tt.fields.DefaultBrowser,
+ connection: tt.fields.connection,
+ sequenceCounter: tt.fields.sequenceCounter,
+ log: testutils.ProduceTestingLogger(t),
+ }
+ got, err := m.getInstalledUnitAddressBytes(tt.args.ctx)
+ if !tt.wantErr(t, err, fmt.Sprintf("getInstalledUnitAddressBytes(%v)", tt.args.ctx)) {
+ return
+ }
+ assert.Equalf(t, tt.want, got, "getInstalledUnitAddressBytes(%v)", tt.args.ctx)
+ t.Log("Banananaaaa")
+ })
})
}
}
diff --git a/plc4go/internal/cbus/Connection_test.go b/plc4go/internal/cbus/Connection_test.go
index fac6c4db37..5ac09fa61f 100644
--- a/plc4go/internal/cbus/Connection_test.go
+++ b/plc4go/internal/cbus/Connection_test.go
@@ -26,6 +26,7 @@ import (
"sync"
"sync/atomic"
"testing"
+ "testing/synctest"
"time"
"github.com/stretchr/testify/assert"
@@ -1465,22 +1466,24 @@ func TestConnection_setupConnection(t *testing.T) {
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
- if tt.setup != nil {
- tt.setup(t, &tt.fields, &tt.args)
- }
- c := &Connection{
- messageCodec: tt.fields.messageCodec,
- subscribers: tt.fields.subscribers,
- tm: tt.fields.tm,
- configuration: tt.fields.configuration,
- driverContext: driverContextForTesting(),
- connectionId: tt.fields.connectionId,
- tracer: tt.fields.tracer,
- log: testutils.ProduceTestingLogger(t),
- }
- c.DefaultConnection = _default.NewDefaultConnection(c, testutils.EnrichOptionsWithOptionsForTesting(t)...)
- err := c.setupConnection(tt.args.ctx)
- tt.wantErr(t, err)
+ synctest.Test(t, func(t *testing.T) {
+ if tt.setup != nil {
+ tt.setup(t, &tt.fields, &tt.args)
+ }
+ c := &Connection{
+ messageCodec: tt.fields.messageCodec,
+ subscribers: tt.fields.subscribers,
+ tm: tt.fields.tm,
+ configuration: tt.fields.configuration,
+ driverContext: driverContextForTesting(),
+ connectionId: tt.fields.connectionId,
+ tracer: tt.fields.tracer,
+ log: testutils.ProduceTestingLogger(t),
+ }
+ c.DefaultConnection = _default.NewDefaultConnection(c, testutils.EnrichOptionsWithOptionsForTesting(t)...)
+ err := c.setupConnection(tt.args.ctx)
+ tt.wantErr(t, err)
+ })
})
}
}
diff --git a/plc4go/internal/cbus/MessageCodec_test.go b/plc4go/internal/cbus/MessageCodec_test.go
index 86a33816e9..4668381006 100644
--- a/plc4go/internal/cbus/MessageCodec_test.go
+++ b/plc4go/internal/cbus/MessageCodec_test.go
@@ -24,6 +24,7 @@ import (
"fmt"
"net/url"
"testing"
+ "testing/synctest"
"time"
"github.com/stretchr/testify/assert"
@@ -639,148 +640,154 @@ func TestMessageCodec_Receive(t *testing.T) {
func TestMessageCodec_Receive_Delayed_Response(t *testing.T) {
t.Run("instant data", func(t *testing.T) {
- _options := testutils.EnrichOptionsWithOptionsForTesting(t)
-
- transport := test.NewTransport(_options...)
- ti, err := transport.CreateTransportInstance(url.URL{Scheme: "test"}, map[string][]string{"simulatedLatency": {"1ms"}}, _options...)
- require.NoError(t, err)
- require.NoError(t, ti.Connect(t.Context()))
- codec := NewMessageCodec(ti, _options...)
- t.Cleanup(func() {
- assert.Error(t, codec.Disconnect())
+ synctest.Test(t, func(t *testing.T) {
+ _options := testutils.EnrichOptionsWithOptionsForTesting(t)
+
+ transport := test.NewTransport(_options...)
+ ti, err := transport.CreateTransportInstance(url.URL{Scheme: "test"}, map[string][]string{"simulatedLatency": {"1ms"}}, _options...)
+ require.NoError(t, err)
+ require.NoError(t, ti.Connect(t.Context()))
+ codec := NewMessageCodec(ti, _options...)
+ t.Cleanup(func() {
+ assert.Error(t, codec.Disconnect())
+ })
+ codec.requestContext = readWriteModel.NewRequestContext(true)
+
+ timeoutCtx := func(timeout time.Duration) context.Context {
+ withTimeout, cancelFunc := context.WithTimeout(t.Context(), timeout)
+ t.Cleanup(cancelFunc)
+ return withTimeout
+ }
+
+ var msg spi.Message
+ msg, err = codec.Receive(timeoutCtx(1 * time.Second))
+ // No data yet so this should return no error and no data
+ assert.NoError(t, err)
+ assert.Nil(t, msg)
+ // Now we add a confirmation
+ ti.(*test.TransportInstance).FillReadBuffer([]byte("i."))
+
+ // We should wait for more data, so no error, no message
+ msg, err = codec.Receive(timeoutCtx(1 * time.Second))
+ assert.NoError(t, err)
+ assert.Nil(t, msg)
+
+ // Now we fill in the payload
+ ti.(*test.TransportInstance).FillReadBuffer([]byte("86FD0201078900434C495053414C20C2\r\n"))
+
+ // We should wait for more data, so no error
+ msg, err = codec.Receive(timeoutCtx(2 * time.Second))
+ assert.NoError(t, err)
+ require.NotNil(t, msg)
+
+ // The message should have a confirmation with an alpha
+ require.Implements(t, (*readWriteModel.CBusMessageToClient)(nil), msg)
+ assert.True(t, msg.(readWriteModel.CBusMessageToClient).GetReply().GetIsAlpha())
})
- codec.requestContext = readWriteModel.NewRequestContext(true)
-
- timeoutCtx := func(timeout time.Duration) context.Context {
- withTimeout, cancelFunc := context.WithTimeout(t.Context(), timeout)
- t.Cleanup(cancelFunc)
- return withTimeout
- }
-
- var msg spi.Message
- msg, err = codec.Receive(timeoutCtx(1 * time.Second))
- // No data yet so this should return no error and no data
- assert.NoError(t, err)
- assert.Nil(t, msg)
- // Now we add a confirmation
- ti.(*test.TransportInstance).FillReadBuffer([]byte("i."))
-
- // We should wait for more data, so no error, no message
- msg, err = codec.Receive(timeoutCtx(1 * time.Second))
- assert.NoError(t, err)
- assert.Nil(t, msg)
-
- // Now we fill in the payload
- ti.(*test.TransportInstance).FillReadBuffer([]byte("86FD0201078900434C495053414C20C2\r\n"))
-
- // We should wait for more data, so no error
- msg, err = codec.Receive(timeoutCtx(2 * time.Second))
- assert.NoError(t, err)
- require.NotNil(t, msg)
-
- // The message should have a confirmation with an alpha
- require.Implements(t, (*readWriteModel.CBusMessageToClient)(nil), msg)
- assert.True(t, msg.(readWriteModel.CBusMessageToClient).GetReply().GetIsAlpha())
})
t.Run("data after 6 times", func(t *testing.T) {
- _options := testutils.EnrichOptionsWithOptionsForTesting(t)
+ t.Run("instant data", func(t *testing.T) {
+ _options := testutils.EnrichOptionsWithOptionsForTesting(t)
- transport := test.NewTransport(_options...)
- ti, err := transport.CreateTransportInstance(url.URL{Scheme: "test"}, map[string][]string{"simulatedLatency": {"1ms"}}, _options...)
- require.NoError(t, err)
+ transport := test.NewTransport(_options...)
+ ti, err := transport.CreateTransportInstance(url.URL{Scheme: "test"}, map[string][]string{"simulatedLatency": {"1ms"}}, _options...)
+ require.NoError(t, err)
- require.NoError(t, ti.Connect(t.Context()))
- codec := NewMessageCodec(ti, _options...)
- t.Cleanup(func() {
- assert.Error(t, codec.Disconnect())
- })
- codec.requestContext = readWriteModel.NewRequestContext(true)
-
- canceledCtx := func() context.Context {
- ctx, cancelFunc := context.WithCancel(t.Context())
- cancelFunc()
- return ctx
- }
- var msg spi.Message
- msg, err = codec.Receive(canceledCtx())
- // No data yet so this should return no error and no data
- assert.NoError(t, err)
- assert.Nil(t, msg)
- // Now we add a confirmation
- ti.(*test.TransportInstance).FillReadBuffer([]byte("i."))
-
- for i := 0; i < 8; i++ {
- t.Logf("%d try", i+1)
- // We should wait for more data, so no error, no message
+ require.NoError(t, ti.Connect(t.Context()))
+ codec := NewMessageCodec(ti, _options...)
+ t.Cleanup(func() {
+ assert.Error(t, codec.Disconnect())
+ })
+ codec.requestContext = readWriteModel.NewRequestContext(true)
+
+ canceledCtx := func() context.Context {
+ ctx, cancelFunc := context.WithCancel(t.Context())
+ cancelFunc()
+ return ctx
+ }
+ var msg spi.Message
msg, err = codec.Receive(canceledCtx())
+ // No data yet so this should return no error and no data
assert.NoError(t, err)
assert.Nil(t, msg)
- }
+ // Now we add a confirmation
+ ti.(*test.TransportInstance).FillReadBuffer([]byte("i."))
- // Now we fill in the payload
- ti.(*test.TransportInstance).FillReadBuffer([]byte("86FD0201078900434C495053414C20C2\r\n"))
+ for i := 0; i < 8; i++ {
+ t.Logf("%d try", i+1)
+ // We should wait for more data, so no error, no message
+ msg, err = codec.Receive(canceledCtx())
+ assert.NoError(t, err)
+ assert.Nil(t, msg)
+ }
- // We should wait for more data, so no error, no message
- msg, err = codec.Receive(t.Context())
- assert.NoError(t, err)
- assert.NotNil(t, msg)
+ // Now we fill in the payload
+ ti.(*test.TransportInstance).FillReadBuffer([]byte("86FD0201078900434C495053414C20C2\r\n"))
- // The message should have a confirmation with an alpha
- require.Implements(t, (*readWriteModel.CBusMessageToClient)(nil), msg)
- cBusMessageToClient := msg.(readWriteModel.CBusMessageToClient)
- assert.True(t, cBusMessageToClient.GetReply().GetIsAlpha())
+ // We should wait for more data, so no error, no message
+ msg, err = codec.Receive(t.Context())
+ assert.NoError(t, err)
+ assert.NotNil(t, msg)
+
+ // The message should have a confirmation with an alpha
+ require.Implements(t, (*readWriteModel.CBusMessageToClient)(nil), msg)
+ cBusMessageToClient := msg.(readWriteModel.CBusMessageToClient)
+ assert.True(t, cBusMessageToClient.GetReply().GetIsAlpha())
+ })
})
t.Run("data after 15 times", func(t *testing.T) {
- _options := testutils.EnrichOptionsWithOptionsForTesting(t)
+ t.Run("instant data", func(t *testing.T) {
+ _options := testutils.EnrichOptionsWithOptionsForTesting(t)
- transport := test.NewTransport(_options...)
- ti, err := transport.CreateTransportInstance(url.URL{Scheme: "test"}, map[string][]string{"simulatedLatency": {"1ms"}}, _options...)
- require.NoError(t, err)
+ transport := test.NewTransport(_options...)
+ ti, err := transport.CreateTransportInstance(url.URL{Scheme: "test"}, map[string][]string{"simulatedLatency": {"1ms"}}, _options...)
+ require.NoError(t, err)
- require.NoError(t, ti.Connect(t.Context()))
- codec := NewMessageCodec(ti, _options...)
- t.Cleanup(func() {
- assert.Error(t, codec.Disconnect())
- })
- codec.requestContext = readWriteModel.NewRequestContext(true)
-
- var msg spi.Message
- msg, err = codec.Receive(t.Context())
- // No data yet so this should return no error and no data
- assert.NoError(t, err)
- assert.Nil(t, msg)
- // Now we add a confirmation
- ti.(*test.TransportInstance).FillReadBuffer([]byte("i."))
-
- for i := 0; i <= 15; i++ {
- t.Logf("%d try", i+1)
- // We should wait for more data, so no error, no message
+ require.NoError(t, ti.Connect(t.Context()))
+ codec := NewMessageCodec(ti, _options...)
+ t.Cleanup(func() {
+ assert.Error(t, codec.Disconnect())
+ })
+ codec.requestContext = readWriteModel.NewRequestContext(true)
+
+ var msg spi.Message
msg, err = codec.Receive(t.Context())
- if i == 15 {
- require.NoError(t, err)
- require.NotNil(t, msg)
- // This should be the confirmation only ...
- reply := msg.(readWriteModel.CBusMessageToClient).GetReply()
- assert.True(t, reply.GetIsAlpha())
- // ... and no content
- assert.Nil(t, reply.(readWriteModel.ReplyOrConfirmationConfirmation).GetEmbeddedReply())
- } else {
- assert.NoError(t, err)
- assert.Nil(t, msg, "Got message at %d try", i+1)
+ // No data yet so this should return no error and no data
+ assert.NoError(t, err)
+ assert.Nil(t, msg)
+ // Now we add a confirmation
+ ti.(*test.TransportInstance).FillReadBuffer([]byte("i."))
+
+ for i := 0; i <= 15; i++ {
+ t.Logf("%d try", i+1)
+ // We should wait for more data, so no error, no message
+ msg, err = codec.Receive(t.Context())
+ if i == 15 {
+ require.NoError(t, err)
+ require.NotNil(t, msg)
+ // This should be the confirmation only ...
+ reply := msg.(readWriteModel.CBusMessageToClient).GetReply()
+ assert.True(t, reply.GetIsAlpha())
+ // ... and no content
+ assert.Nil(t, reply.(readWriteModel.ReplyOrConfirmationConfirmation).GetEmbeddedReply())
+ } else {
+ assert.NoError(t, err)
+ assert.Nil(t, msg, "Got message at %d try", i+1)
+ }
}
- }
- // Now we fill in the payload
- ti.(*test.TransportInstance).FillReadBuffer([]byte("86FD0201078900434C495053414C20C2\r\n"))
+ // Now we fill in the payload
+ ti.(*test.TransportInstance).FillReadBuffer([]byte("86FD0201078900434C495053414C20C2\r\n"))
- // We should wait for more data, so no error, no message
- msg, err = codec.Receive(t.Context())
- assert.NoError(t, err)
- assert.NotNil(t, msg)
+ // We should wait for more data, so no error, no message
+ msg, err = codec.Receive(t.Context())
+ assert.NoError(t, err)
+ assert.NotNil(t, msg)
- // The message should have a confirmation without an alpha
- require.Implements(t, (*readWriteModel.CBusMessageToClient)(nil), msg)
- assert.False(t, msg.(readWriteModel.CBusMessageToClient).GetReply().GetIsAlpha())
+ // The message should have a confirmation without an alpha
+ require.Implements(t, (*readWriteModel.CBusMessageToClient)(nil), msg)
+ assert.False(t, msg.(readWriteModel.CBusMessageToClient).GetReply().GetIsAlpha())
+ })
})
}
diff --git a/plc4go/spi/testutils/ParserSerializerTestRunner.go b/plc4go/spi/testutils/ParserSerializerTestRunner.go
index bebef56e57..5d1359da7e 100644
--- a/plc4go/spi/testutils/ParserSerializerTestRunner.go
+++ b/plc4go/spi/testutils/ParserSerializerTestRunner.go
@@ -28,6 +28,7 @@ import (
"strconv"
"strings"
"testing"
+ "testing/synctest"
"github.com/pkg/errors"
"github.com/stretchr/testify/assert"
@@ -207,9 +208,11 @@ func RunParserSerializerTestsuite(t *testing.T, testPath string, parser Parser,
return
}
t.Logf("Running testcase %s", testcase.name)
- if err := testsuite.Run(t, testcase); err != nil {
- t.Fatalf("\n-------------------------------------------------------\nFailure\n%+v\n-------------------------------------------------------\n\n", err)
- }
+ synctest.Test(t, func(t *testing.T) {
+ if err := testsuite.Run(t, testcase); err != nil {
+ t.Fatalf("\n-------------------------------------------------------\nFailure\n%+v\n-------------------------------------------------------\n\n", err)
+ }
+ })
})
}
t.Log("Done running testcases")