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 2023/04/21 12:08:22 UTC

[plc4x] branch develop updated (faf7dc160e -> a3eca409ca)

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

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


    from faf7dc160e feat(bacnet): update vendors
     new e2436975ff test(plc4go): greatly improve test runners
     new a3eca409ca test(plc4go): refactor ParserSerializerTestRunner to align with DriverTestRunner

The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.


Summary of changes:
 plc4go/spi/testutils/DriverTestRunner.go           | 265 +++++++-------
 plc4go/spi/testutils/ManualTestRunner.go           |  12 +-
 plc4go/spi/testutils/ParserSerializerTestRunner.go | 404 ++++++++++++---------
 plc4go/tests/drivers/tests/abeth_driver_test.go    |   3 +-
 .../drivers/tests/abeth_parser_serializer_test.go  |   6 +-
 plc4go/tests/drivers/tests/ads_driver_test.go      |   6 +-
 .../drivers/tests/ads_parser_serializer_test.go    |   6 +-
 .../drivers/tests/bacnet_parser_serializer_test.go |   6 +-
 plc4go/tests/drivers/tests/df1_driver_test.go      |   3 +-
 .../drivers/tests/df1_parser_serializer_test.go    |   6 +-
 plc4go/tests/drivers/tests/eip_driver_test.go      |   4 +-
 .../drivers/tests/eip_parser_serializer_test.go    |   5 +-
 plc4go/tests/drivers/tests/firmata_driver_test.go  |   3 +-
 .../tests/firmata_parser_serializer_test.go        |   6 +-
 plc4go/tests/drivers/tests/knxnetip_driver_test.go |   6 +-
 .../tests/knxnetip_parser_serializer_test.go       |   6 +-
 .../tests/drivers/tests/manual_ads_driver_test.go  |   5 +-
 .../drivers/tests/manual_bacnet_PcapTest_test.go   |   6 +-
 .../drivers/tests/manual_bacnet_driver_test.go     |  18 +-
 plc4go/tests/drivers/tests/manual_bacnet_test.go   |   1 +
 .../tests/drivers/tests/manual_cbus_driver_test.go |  35 +-
 .../tests/drivers/tests/manual_s7_driver_test.go   |   5 +-
 plc4go/tests/drivers/tests/modbus_driver_test.go   |   6 +-
 .../drivers/tests/modbus_parser_serializer_test.go |  10 +-
 plc4go/tests/drivers/tests/s7_driver_test.go       |   6 +-
 .../drivers/tests/s7_parser_serializer_test.go     |   6 +-
 plc4go/tests/initializetest/init.go                |  19 +
 27 files changed, 463 insertions(+), 401 deletions(-)


[plc4x] 01/02: test(plc4go): greatly improve test runners

Posted by sr...@apache.org.
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 e2436975ff925c1a97330f9b561f27e2d7b14d3d
Author: Sebastian Rühl <sr...@apache.org>
AuthorDate: Fri Apr 21 12:52:04 2023 +0200

    test(plc4go): greatly improve test runners
    
    + use *testing.T whenever possible
---
 plc4go/spi/testutils/DriverTestRunner.go           | 174 ++++++++++-----------
 plc4go/spi/testutils/ManualTestRunner.go           |  12 +-
 plc4go/spi/testutils/ParserSerializerTestRunner.go |   4 +-
 plc4go/tests/drivers/tests/ads_driver_test.go      |   6 +-
 plc4go/tests/drivers/tests/knxnetip_driver_test.go |   6 +-
 .../tests/drivers/tests/manual_ads_driver_test.go  |   2 +-
 .../drivers/tests/manual_bacnet_driver_test.go     |  15 +-
 .../tests/drivers/tests/manual_cbus_driver_test.go |  34 +---
 .../tests/drivers/tests/manual_s7_driver_test.go   |   2 +-
 plc4go/tests/drivers/tests/modbus_driver_test.go   |   6 +-
 plc4go/tests/drivers/tests/s7_driver_test.go       |   6 +-
 plc4go/tests/initializetest/init.go                |  19 +++
 12 files changed, 129 insertions(+), 157 deletions(-)

diff --git a/plc4go/spi/testutils/DriverTestRunner.go b/plc4go/spi/testutils/DriverTestRunner.go
index 57f236d822..8bdee21151 100644
--- a/plc4go/spi/testutils/DriverTestRunner.go
+++ b/plc4go/spi/testutils/DriverTestRunner.go
@@ -32,13 +32,13 @@ import (
 	"time"
 
 	"github.com/apache/plc4x/plc4go/pkg/api"
-	api "github.com/apache/plc4x/plc4go/pkg/api/model"
+	apiModel "github.com/apache/plc4x/plc4go/pkg/api/model"
 	"github.com/apache/plc4x/plc4go/spi"
 	"github.com/apache/plc4x/plc4go/spi/transports"
 	"github.com/apache/plc4x/plc4go/spi/transports/test"
 	"github.com/apache/plc4x/plc4go/spi/utils"
+
 	"github.com/pkg/errors"
-	"github.com/rs/zerolog/log"
 	"github.com/subchen/go-xmldom"
 )
 
@@ -64,18 +64,33 @@ type WithOption interface {
 	isOption() bool
 }
 
-type option struct {
+type _option struct {
 }
 
-func (_ option) isOption() bool {
+func (_option) isOption() bool {
 	return true
 }
 
-// WithRootTypeParser Can be used to output the root type of a protocol for better debugging
+// WithRootTypeParser can be used to output the root type of a protocol for better debugging
 func WithRootTypeParser(rootTypeParser func(utils.ReadBufferByteBased) (any, error)) WithOption {
 	return withRootTypeParser{rootTypeParser: rootTypeParser}
 }
 
+type withRootTypeParser struct {
+	_option
+	rootTypeParser func(utils.ReadBufferByteBased) (any, error)
+}
+
+// WithSkippedTestCases can be used to skip test cases
+func WithSkippedTestCases(skippedTestCases ...string) WithOption {
+	return withSkippedTestCases{skippedTestCases: skippedTestCases}
+}
+
+type withSkippedTestCases struct {
+	_option
+	skippedTestCases []string
+}
+
 type TestTransportInstance interface {
 	transports.TransportInstance
 	FillReadBuffer(data []byte)
@@ -83,11 +98,6 @@ type TestTransportInstance interface {
 	DrainWriteBuffer(numBytes uint32) []byte
 }
 
-type withRootTypeParser struct {
-	option
-	rootTypeParser func(utils.ReadBufferByteBased) (any, error)
-}
-
 func (m DriverTestsuite) Run(t *testing.T, driverManager plc4go.PlcDriverManager, testcase Testcase) error {
 	var options []string
 	for key, value := range m.driverParameters {
@@ -106,10 +116,10 @@ func (m DriverTestsuite) Run(t *testing.T, driverManager plc4go.PlcDriverManager
 	}
 	connection := connectionResult.GetConnection()
 
-	log.Info().Msgf("\n-------------------------------------------------------\nExecuting testcase: %s \n-------------------------------------------------------\n", testcase.name)
+	t.Logf("\n-------------------------------------------------------\nExecuting testcase: %s \n-------------------------------------------------------\n", testcase.name)
 
 	// Run the setup steps
-	log.Info().Msgf("\n-------------------------------------------------------\nPerforming setup for: %s \n-------------------------------------------------------\n", testcase.name)
+	t.Logf("\n-------------------------------------------------------\nPerforming setup for: %s \n-------------------------------------------------------\n", testcase.name)
 	for _, testStep := range m.setupSteps {
 		err := m.ExecuteStep(t, connection, &testcase, testStep)
 		if err != nil {
@@ -120,7 +130,7 @@ func (m DriverTestsuite) Run(t *testing.T, driverManager plc4go.PlcDriverManager
 	}
 
 	// Run the actual scenario steps
-	log.Info().Msgf("\n-------------------------------------------------------\nRunning testcases for: %s \n-------------------------------------------------------\n", testcase.name)
+	t.Logf("\n-------------------------------------------------------\nRunning testcases for: %s \n-------------------------------------------------------\n", testcase.name)
 	for _, testStep := range testcase.steps {
 		err := m.ExecuteStep(t, connection, &testcase, testStep)
 		if err != nil {
@@ -130,7 +140,7 @@ func (m DriverTestsuite) Run(t *testing.T, driverManager plc4go.PlcDriverManager
 	}
 
 	// Run the teardown steps
-	log.Info().Msgf("\n-------------------------------------------------------\nPerforming teardown for: %s \n-------------------------------------------------------\n", testcase.name)
+	t.Logf("\n-------------------------------------------------------\nPerforming teardown for: %s \n-------------------------------------------------------\n", testcase.name)
 	for _, testStep := range m.teardownSteps {
 		err := m.ExecuteStep(t, connection, &testcase, testStep)
 		if err != nil {
@@ -139,7 +149,7 @@ func (m DriverTestsuite) Run(t *testing.T, driverManager plc4go.PlcDriverManager
 		time.Sleep(10 * time.Millisecond)
 	}
 
-	log.Info().Msgf("\n-------------------------------------------------------\nDone\n-------------------------------------------------------\n")
+	t.Logf("\n-------------------------------------------------------\nDone\n-------------------------------------------------------\n")
 	return nil
 }
 
@@ -154,15 +164,15 @@ func (m DriverTestsuite) ExecuteStep(t *testing.T, connection plc4go.PlcConnecti
 	}
 
 	start := time.Now()
-	log.Info().Msgf("\n-------------------------------------------------------\n - Executing step: %s \n-------------------------------------------------------\n", step.name)
+	t.Logf("\n-------------------------------------------------------\n - Executing step: %s \n-------------------------------------------------------\n", step.name)
 
-	log.Debug().Stringer("stepType", step.stepType).Msg("Handling step")
+	t.Logf("Handling step %s", step.stepType)
 	switch step.stepType {
 	case StepTypeApiRequest:
 		switch step.payload.Name {
 		case "TestReadRequest":
 			// Assemble a read-request according to the information in the test xml
-			log.Trace().Msg("Assemble read request")
+			t.Log("Assemble read request")
 			rrb := connection.ReadRequestBuilder()
 			for _, tagNode := range step.payload.GetChild("tags").GetChildren("tag") {
 				tagName := tagNode.GetChild("name").Text
@@ -175,13 +185,13 @@ func (m DriverTestsuite) ExecuteStep(t *testing.T, connection plc4go.PlcConnecti
 			}
 
 			// Execute the read-request and store the response-channel in the testcase.
-			log.Trace().Msg("Execute read request")
+			t.Log("Execute read request")
 			if testcase.readRequestResultChannel != nil {
 				return errors.New("testcase read-request result channel already occupied")
 			}
 			testcase.readRequestResultChannel = readRequest.Execute()
 		case "TestWriteRequest":
-			log.Trace().Msg("Assemble write request")
+			t.Log("Assemble write request")
 			wrb := connection.WriteRequestBuilder()
 			for _, tagNode := range step.payload.GetChild("tags").GetChildren("tag") {
 				tagName := tagNode.GetChild("name").Text
@@ -210,7 +220,7 @@ func (m DriverTestsuite) ExecuteStep(t *testing.T, connection plc4go.PlcConnecti
 			if err != nil {
 				return errors.Wrap(err, "Error creating write-request")
 			}
-			log.Trace().Msg("Execute write request")
+			t.Log("Execute write request")
 			if testcase.writeRequestResultChannel != nil {
 				return errors.New("testcase write-request result channel already occupied")
 			}
@@ -222,7 +232,7 @@ func (m DriverTestsuite) ExecuteStep(t *testing.T, connection plc4go.PlcConnecti
 			if testcase.readRequestResultChannel == nil {
 				return errors.New("no read response expected")
 			}
-			log.Trace().Msg("Waiting for read request result")
+			t.Log("Waiting for read request result")
 			readRequestResult := <-testcase.readRequestResultChannel
 			if readRequestResult.GetErr() != nil {
 				return errors.Wrap(readRequestResult.GetErr(), "error sending response")
@@ -247,7 +257,7 @@ func (m DriverTestsuite) ExecuteStep(t *testing.T, connection plc4go.PlcConnecti
 			if testcase.writeRequestResultChannel == nil {
 				return errors.New("no write response expected")
 			}
-			log.Trace().Msg("Waiting for write request result")
+			t.Log("Waiting for write request result")
 			writeResponseResult := <-testcase.writeRequestResultChannel
 			if writeResponseResult.GetErr() != nil {
 				return errors.Wrap(writeResponseResult.GetErr(), "error sending response")
@@ -274,14 +284,14 @@ func (m DriverTestsuite) ExecuteStep(t *testing.T, connection plc4go.PlcConnecti
 		payloadString := step.payload.XMLPretty()
 
 		// Parse the xml into a real model
-		log.Trace().Msg("parsing xml")
+		t.Log("parsing xml")
 		expectedMessage, err := m.parseMessage(typeName, payloadString, step)
 		if err != nil {
 			return errors.Wrap(err, "Error parsing message")
 		}
 
 		// Serialize the model into bytes
-		log.Trace().Msg("Write to bytes")
+		t.Log("Write to bytes")
 		expectedSerializable, ok := expectedMessage.(utils.Serializable)
 		if !ok {
 			return errors.Errorf("error converting type %t into Serializable type", expectedMessage)
@@ -301,7 +311,7 @@ func (m DriverTestsuite) ExecuteStep(t *testing.T, connection plc4go.PlcConnecti
 
 		now := time.Now()
 		// Read exactly this amount of bytes from the transport
-		log.Trace().Uint32("expectedRawOutputLength", expectedRawOutputLength).Msg("Reading bytes")
+		t.Logf("Reading bytes (expectedRawOutputLength %d)", expectedRawOutputLength)
 		for testTransportInstance.GetNumDrainableBytes() < expectedRawOutputLength {
 			if time.Now().Sub(now) > 2*time.Second {
 				drainableBytes := testTransportInstance.GetNumDrainableBytes()
@@ -325,13 +335,13 @@ func (m DriverTestsuite) ExecuteStep(t *testing.T, connection plc4go.PlcConnecti
 			}
 		}
 		// Compare the bytes read with the ones we expect
-		log.Trace().Msg("Comparing outputs")
+		t.Log("Comparing outputs")
 		for i := range expectedRawOutput {
 			if expectedRawOutput[i] != actualRawOutput[i] {
 				if m.rootTypeParser != nil {
 					readBufferByteBased := bufferFactory(actualRawOutput)
 					actual, err := m.rootTypeParser(readBufferByteBased)
-					log.Error().Err(err).Msgf("A readable render of expectation:\n%v\nvs actual paket\n%v\n", expectedSerializable, actual)
+					t.Logf("A readable render of expectation:\n%v\nvs actual paket\n%v\n%#v", expectedSerializable, actual, err)
 				}
 				return errors.Errorf("actual output doesn't match expected output:\nactual:   0x%X\nexpected: 0x%X\nHexdumps:\n%s", actualRawOutput, expectedRawOutput, utils.DiffHex(expectedRawOutput, actualRawOutput))
 			}
@@ -339,7 +349,7 @@ func (m DriverTestsuite) ExecuteStep(t *testing.T, connection plc4go.PlcConnecti
 		// If there's a difference, parse the input and display it to simplify debugging
 	case StepTypeOutgoingPlcBytes:
 		// Read exactly this amount of bytes from the transport
-		log.Trace().Msg("Reading bytes")
+		t.Log("Reading bytes")
 		expectedRawInput, err := hex.DecodeString(step.payload.Text)
 		if err != nil {
 			return errors.Wrap(err, "error decoding hex-encoded byte data")
@@ -347,7 +357,7 @@ func (m DriverTestsuite) ExecuteStep(t *testing.T, connection plc4go.PlcConnecti
 		rawInput := testTransportInstance.DrainWriteBuffer(uint32(len(expectedRawInput)))
 
 		// Compare the bytes read with the ones we expect
-		log.Trace().Msg("Comparing bytes")
+		t.Log("Comparing bytes")
 		for i := range expectedRawInput {
 			if expectedRawInput[i] != rawInput[i] {
 				return errors.Errorf("actual output doesn't match expected output:\nactual:   0x%X\nexpected: 0x%X\nHexdumps:\n%s", rawInput, expectedRawInput, utils.DiffHex(expectedRawInput, rawInput))
@@ -359,14 +369,14 @@ func (m DriverTestsuite) ExecuteStep(t *testing.T, connection plc4go.PlcConnecti
 		payloadString := step.payload.XMLPretty()
 
 		// Parse the xml into a real model
-		log.Trace().Msg("Parsing model")
+		t.Log("Parsing model")
 		expectedMessage, err := m.parseMessage(typeName, payloadString, step)
 		if err != nil {
 			return errors.Wrap(err, "error parsing message")
 		}
 
 		// Serialize the model into bytes
-		log.Trace().Msg("Serializing bytes")
+		t.Log("Serializing bytes")
 		expectedSerializable, ok := expectedMessage.(utils.Serializable)
 		if !ok {
 			return errors.New("error converting type into Serializable type")
@@ -383,38 +393,38 @@ func (m DriverTestsuite) ExecuteStep(t *testing.T, connection plc4go.PlcConnecti
 		}
 
 		// Send these bytes to the transport
-		log.Trace().Msg("Writing to transport")
+		t.Log("Writing to transport")
 		testTransportInstance.FillReadBuffer(wb.GetBytes())
 	case StepTypeIncomingPlcBytes:
 		// Get the raw hex-data.
-		log.Trace().Msg("Get hex data")
+		t.Log("Get hex data")
 		rawInput, err := hex.DecodeString(step.payload.Text)
 		if err != nil {
 			return errors.Wrap(err, "error decoding hex-encoded byte data: ")
 		}
 
 		// Send these bytes to the transport
-		log.Trace().Msg("Writing bytes to transport")
+		t.Log("Writing bytes to transport")
 		testTransportInstance.FillReadBuffer(rawInput)
 	case StepTypeDelay:
 		// Get the number of milliseconds
-		log.Trace().Msg("Getting millis")
+		t.Log("Getting millis")
 		delay, err := strconv.Atoi(step.payload.Text)
 		if err != nil {
 			return errors.Wrap(err, "invalid delay format")
 		}
 		// Sleep for that long
-		log.Debug().Int("delay", delay).Msg("Sleeping")
+		t.Logf("Sleeping (delay: %dms)", delay)
 		time.Sleep(time.Duration(delay) * time.Millisecond)
 	case StepTypeTerminate:
 		// Simply close the transport connection
-		log.Trace().Msg("closing transport")
+		t.Log("closing transport")
 		err := testTransportInstance.Close()
 		if err != nil {
 			return errors.Wrap(err, "error closing transport")
 		}
 	}
-	log.Info().Msgf("\n\n-------------------------------------------------------\n - Finished step: %s after %vms \n-------------------------------------------------------", step.name, time.Now().Sub(start).Milliseconds())
+	t.Logf("\n-------------------------------------------------------\n - Finished step: %s after %vms \n-------------------------------------------------------", step.name, time.Now().Sub(start).Milliseconds())
 	return nil
 }
 
@@ -437,8 +447,8 @@ func (m DriverTestsuite) ParseXml(referenceXml *xmldom.Node, parserArguments []s
 type Testcase struct {
 	name                      string
 	steps                     []TestStep
-	readRequestResultChannel  <-chan api.PlcReadRequestResult
-	writeRequestResultChannel <-chan api.PlcWriteRequestResult
+	readRequestResultChannel  <-chan apiModel.PlcReadRequestResult
+	writeRequestResultChannel <-chan apiModel.PlcWriteRequestResult
 }
 
 type TestStep struct {
@@ -462,42 +472,33 @@ const (
 	StepTypeTerminate          StepType = 0x08
 )
 
-func RunDriverTestsuite(t *testing.T, driver plc4go.PlcDriver, testPath string, parser XmlParser, skippedTestCases ...string) {
-	RunDriverTestsuiteWithOptions(t, driver, testPath, parser, nil, skippedTestCases...)
-}
-
-func RunDriverTestsuiteWithOptions(t *testing.T, driver plc4go.PlcDriver, testPath string, parser XmlParser, options []WithOption, skippedTestCases ...string) {
+func RunDriverTestsuite(t *testing.T, driver plc4go.PlcDriver, testPath string, parser XmlParser, options ...WithOption) {
+	t.Log("Extract testsuite options")
+	var rootTypeParser func(utils.ReadBufferByteBased) (any, error)
 	skippedTestCasesMap := map[string]bool{}
-	for _, skippedTestCase := range skippedTestCases {
-		skippedTestCasesMap[skippedTestCase] = true
+	for _, withOption := range options {
+		switch option := withOption.(type) {
+		case withRootTypeParser:
+			t.Logf("Using root type parser for better output")
+			rootTypeParser = option.rootTypeParser
+		case withSkippedTestCases:
+			t.Log("Skipping test cases:")
+			for _, skippedTestCase := range option.skippedTestCases {
+				t.Logf("Skipping %s", skippedTestCase)
+				skippedTestCasesMap[skippedTestCase] = true
+			}
+		}
 	}
 	// Read the test-specification as XML file
 	rootNode, err := ParseDriverTestsuiteXml(testPath)
 	if err != nil {
-		t.Error(err.Error())
-		t.Fail()
-		return
+		t.Fatal(err)
 	}
 
-	var rootTypeParser func(utils.ReadBufferByteBased) (any, error)
-	for _, withOption := range options {
-		switch withOption.(type) {
-		case withRootTypeParser:
-			log.Info().Msg("Using root type parser for better output")
-			rootTypeParser = withOption.(withRootTypeParser).rootTypeParser
-		}
-	}
 	// Parse the contents of the test-specification
-	testsuite, err := ParseDriverTestsuite(*rootNode, parser, rootTypeParser)
+	testsuite, err := ParseDriverTestsuite(t, *rootNode, parser, rootTypeParser)
 	if err != nil {
-		// TODO: zerolog doesn't render stack human readable :(
-		fmt.Printf("%+v\n", err)
-		log.Error().
-			Stack().
-			Err(err).
-			Msg("Failed to parse test-specification")
-		t.Error(err)
-		t.Fail()
+		t.Fatal(err)
 		return
 	}
 
@@ -512,28 +513,28 @@ func RunDriverTestsuiteWithOptions(t *testing.T, driver plc4go.PlcDriver, testPa
 	driverManager.(spi.TransportAware).RegisterTransport(test.NewTransport())
 	driverManager.RegisterDriver(driver)
 
+	t.Logf("Running %d testcases", len(testsuite.testcases))
 	for _, testcase := range testsuite.testcases {
 		t.Run(testcase.name, func(t *testing.T) {
 			defer func() {
 				if err := recover(); err != nil {
-					log.Error().Msgf("\n-------------------------------------------------------\nPanic Failure\n%+v\n%s\n-------------------------------------------------------\n\n", err, debug.Stack())
-					t.FailNow()
+					t.Fatalf("\n-------------------------------------------------------\nPanic Failure\n%+v\n%s\n-------------------------------------------------------\n\n", err, debug.Stack())
 				}
 			}()
 			if skippedTestCasesMap[testcase.name] {
-				log.Warn().Msgf("Testcase %s skipped", testcase.name)
+				t.Logf("Testcase %s skipped", testcase.name)
 				t.Skipf("Testcase %s skipped", testcase.name)
 				return
 			}
-			log.Info().Msgf("Running testcase %s", testcase.name)
+			t.Logf("Running testcase %s", testcase.name)
 			if err := testsuite.Run(t, driverManager, testcase); err != nil {
-				log.Error().Err(err).Msgf("\n-------------------------------------------------------\nFailure\n%+v\n-------------------------------------------------------\n\n", err)
-				t.Fail()
+				t.Fatalf("\n-------------------------------------------------------\nFailure\n%+v\n-------------------------------------------------------\n\n", err)
 			}
 		})
 	}
+	t.Log("Done running testcases")
 	// Execute the tests in the testsuite
-	log.Info().Msgf(testsuite.name)
+	t.Logf(testsuite.name)
 }
 
 type ConnectionConnectAwaiter interface {
@@ -572,7 +573,7 @@ func ParseDriverTestsuiteXml(testPath string) (*xmldom.Node, error) {
 	return node, nil
 }
 
-func ParseDriverTestsuite(node xmldom.Node, parser XmlParser, rootTypeParser func(utils.ReadBufferByteBased) (any, error)) (*DriverTestsuite, error) {
+func ParseDriverTestsuite(t *testing.T, node xmldom.Node, parser XmlParser, rootTypeParser func(utils.ReadBufferByteBased) (any, error)) (*DriverTestsuite, error) {
 	if node.Name != "driver-testsuite" {
 		return nil, errors.New("invalid document structure")
 	}
@@ -616,13 +617,13 @@ func ParseDriverTestsuite(node xmldom.Node, parser XmlParser, rootTypeParser fun
 				driverParameters[name] = value
 			}
 		} else if child.Name == "setup" {
-			steps, err := ParseDriverTestsuiteSteps(child)
+			steps, err := ParseDriverTestsuiteSteps(t, child)
 			if err != nil {
 				return nil, errors.Wrap(err, "error parsing setup steps")
 			}
 			setupSteps = steps
 		} else if child.Name == "teardown" {
-			steps, err := ParseDriverTestsuiteSteps(child)
+			steps, err := ParseDriverTestsuiteSteps(t, child)
 			if err != nil {
 				return nil, errors.Wrap(err, "error teardown setup steps")
 			}
@@ -630,7 +631,7 @@ func ParseDriverTestsuite(node xmldom.Node, parser XmlParser, rootTypeParser fun
 		} else if child.Name == "testcase" {
 			testcaseName := child.FindOneByName("name").Text
 			stepsNode := child.FindOneByName("steps")
-			steps, err := ParseDriverTestsuiteSteps(*stepsNode)
+			steps, err := ParseDriverTestsuiteSteps(t, *stepsNode)
 			if err != nil {
 				return nil, errors.Wrap(err, "error parsing testcase "+testcaseName)
 			}
@@ -643,10 +644,7 @@ func ParseDriverTestsuite(node xmldom.Node, parser XmlParser, rootTypeParser fun
 			return nil, errors.New("invalid document structure. Unhandled element " + child.Name)
 		}
 	}
-	log.Info().
-		Str("testsuite name", testsuiteName).
-		Str("driver name", driverName).
-		Msgf("Parsed test suite %s", testsuiteName)
+	t.Logf("Parsed testsuite name: %s, driver name: %s", testsuiteName, driverName)
 
 	return &DriverTestsuite{
 		name:             testsuiteName,
@@ -663,12 +661,12 @@ func ParseDriverTestsuite(node xmldom.Node, parser XmlParser, rootTypeParser fun
 	}, nil
 }
 
-func ParseDriverTestsuiteSteps(node xmldom.Node) ([]TestStep, error) {
-	log.Debug().Str("rootElement", node.Name).Msg("Parsing driver testsuite steps")
+func ParseDriverTestsuiteSteps(t *testing.T, node xmldom.Node) ([]TestStep, error) {
+	t.Logf("Parsing driver testsuite steps (rootElement %s)", node.Name)
 	var testSteps []TestStep
 	for _, step := range node.Children {
 		name := step.GetAttributeValue("name")
-		log.Debug().Str("rootElement", node.Name).Str("name", name).Msg("Parsing step")
+		t.Logf("Parsing step (name: %s, rootElement %s)", name, node.Name)
 		var stepType StepType
 		switch step.Name {
 		case "api-request":
@@ -692,9 +690,9 @@ func ParseDriverTestsuiteSteps(node xmldom.Node) ([]TestStep, error) {
 		}
 		var parserArguments []string
 		var payload *xmldom.Node
-		log.Debug().Str("rootElement", node.Name).Msg("Looking for payload")
+		t.Logf("Looking for payload (name: %s, rootElement %s)", name, node.Name)
 		for _, childNode := range step.Children {
-			log.Debug().Str("child node name", childNode.Name).Str("rootElement", node.Name).Msg("Found payload candidate")
+			t.Logf("Found payload candidate (child node name: %s, name: %s, rootElement %s)", childNode.Name, name, node.Name)
 			if childNode.Name == "parser-arguments" {
 				for _, parserArgumentNode := range childNode.Children {
 					parserArguments = append(parserArguments, parserArgumentNode.Text)
diff --git a/plc4go/spi/testutils/ManualTestRunner.go b/plc4go/spi/testutils/ManualTestRunner.go
index c65e2cd09e..2ec36ccfde 100644
--- a/plc4go/spi/testutils/ManualTestRunner.go
+++ b/plc4go/spi/testutils/ManualTestRunner.go
@@ -31,7 +31,7 @@ import (
 	"github.com/apache/plc4x/plc4go/pkg/api"
 	"github.com/apache/plc4x/plc4go/pkg/api/model"
 	"github.com/apache/plc4x/plc4go/spi/values"
-	"github.com/rs/zerolog/log"
+
 	"github.com/stretchr/testify/assert"
 )
 
@@ -74,7 +74,7 @@ func WithUnwrappedValue(unwrap bool) WithTestCaseOption {
 	}
 }
 
-func (m *ManualTestSuite) Run() plc4go.PlcConnection {
+func (m *ManualTestSuite) Run(t *testing.T) plc4go.PlcConnection {
 	connectionResult := <-m.DriverManager.GetConnection(m.ConnectionString)
 	if err := connectionResult.GetErr(); err != nil {
 		tracer, ok := errors.Cause(err).(interface{ StackTrace() errors.StackTrace })
@@ -92,7 +92,7 @@ func (m *ManualTestSuite) Run() plc4go.PlcConnection {
 	m.t.Cleanup(func() {
 		connection.Close()
 	})
-	log.Info().Msg("Reading all types in separate requests")
+	t.Log("Reading all types in separate requests")
 	// Run all entries separately:
 	for _, testCase := range m.TestCases {
 		tagName := testCase.Address
@@ -155,9 +155,9 @@ func (m *ManualTestSuite) runSingleTest(t *testing.T, connection plc4go.PlcConne
 func (m *ManualTestSuite) runBurstTest(t *testing.T, connection plc4go.PlcConnection) {
 	// Read all items in one big request.
 	// Shuffle the list of test cases and run the test 10 times.
-	log.Info().Msg("Reading all items together in random order")
+	t.Log("Reading all items together in random order")
 	for i := 0; i < 100; i++ {
-		log.Info().Msgf(" - run number %d of %d", i, 100)
+		t.Logf(" - run number %d of %d", i, 100)
 		shuffledTestcases := append(make([]ManualTestCase, 0), m.TestCases...)
 		rand.Seed(time.Now().UnixNano())
 		rand.Shuffle(len(shuffledTestcases), func(i, j int) {
@@ -169,7 +169,7 @@ func (m *ManualTestSuite) runBurstTest(t *testing.T, connection plc4go.PlcConnec
 			sb.WriteString(testCase.Address)
 			sb.WriteString(", ")
 		}
-		log.Info().Msgf("       using order: %s", sb.String())
+		t.Logf("       using order: %s", sb.String())
 
 		builder := connection.ReadRequestBuilder()
 		for _, testCase := range shuffledTestcases {
diff --git a/plc4go/spi/testutils/ParserSerializerTestRunner.go b/plc4go/spi/testutils/ParserSerializerTestRunner.go
index 6d39953a7c..c0fbec8e21 100644
--- a/plc4go/spi/testutils/ParserSerializerTestRunner.go
+++ b/plc4go/spi/testutils/ParserSerializerTestRunner.go
@@ -39,7 +39,7 @@ import (
 	modbusModel "github.com/apache/plc4x/plc4go/protocols/modbus/readwrite"
 	s7Model "github.com/apache/plc4x/plc4go/protocols/s7/readwrite"
 	"github.com/apache/plc4x/plc4go/spi/utils"
-	"github.com/rs/zerolog/log"
+
 	"github.com/stretchr/testify/assert"
 	"github.com/subchen/go-xmldom"
 )
@@ -104,7 +104,7 @@ func RunParserSerializerTestsuite(t *testing.T, testPath string, skippedTestCase
 			testCaseName := child.FindOneByName("name").Text
 			t.Run(testCaseName, func(t *testing.T) {
 				if skippedTestCasesMap[testCaseName] {
-					log.Warn().Msgf("Testcase %s skipped", testCaseName)
+					t.Logf("Testcase %s skipped", testCaseName)
 					t.Skipf("Testcase %s skipped", testCaseName)
 					return
 				}
diff --git a/plc4go/tests/drivers/tests/ads_driver_test.go b/plc4go/tests/drivers/tests/ads_driver_test.go
index 7fc7fca8dc..0cf15a4907 100644
--- a/plc4go/tests/drivers/tests/ads_driver_test.go
+++ b/plc4go/tests/drivers/tests/ads_driver_test.go
@@ -33,8 +33,8 @@ import (
 
 func TestAdsDriver(t *testing.T) {
 	t.Skip("I have to port the commands for reading the symbol-table first")
-	options := []testutils.WithOption{testutils.WithRootTypeParser(func(readBufferByteBased utils.ReadBufferByteBased) (any, error) {
+	parser := func(readBufferByteBased utils.ReadBufferByteBased) (any, error) {
 		return adsModel.AmsTCPPacketParseWithBuffer(context.Background(), readBufferByteBased)
-	})}
-	testutils.RunDriverTestsuiteWithOptions(t, ads.NewDriver(), "assets/testing/protocols/ads/DriverTestsuite.xml", adsIO.AdsXmlParserHelper{}, options)
+	}
+	testutils.RunDriverTestsuite(t, ads.NewDriver(), "assets/testing/protocols/ads/DriverTestsuite.xml", adsIO.AdsXmlParserHelper{}, testutils.WithRootTypeParser(parser))
 }
diff --git a/plc4go/tests/drivers/tests/knxnetip_driver_test.go b/plc4go/tests/drivers/tests/knxnetip_driver_test.go
index d55e1b7989..8008fedeba 100644
--- a/plc4go/tests/drivers/tests/knxnetip_driver_test.go
+++ b/plc4go/tests/drivers/tests/knxnetip_driver_test.go
@@ -33,8 +33,8 @@ import (
 
 func TestKNXNetIPDriver(t *testing.T) {
 	t.Skip("No test yet")
-	options := []testutils.WithOption{testutils.WithRootTypeParser(func(readBufferByteBased utils.ReadBufferByteBased) (any, error) {
+	parser := func(readBufferByteBased utils.ReadBufferByteBased) (any, error) {
 		return knxModel.KnxNetIpMessageParseWithBuffer(context.Background(), readBufferByteBased)
-	})}
-	testutils.RunDriverTestsuiteWithOptions(t, knxnetip.NewDriver(), "assets/testing/protocols/knxnetip/DriverTestsuite.xml", knxIO.KnxnetipXmlParserHelper{}, options)
+	}
+	testutils.RunDriverTestsuite(t, knxnetip.NewDriver(), "assets/testing/protocols/knxnetip/DriverTestsuite.xml", knxIO.KnxnetipXmlParserHelper{}, testutils.WithRootTypeParser(parser))
 }
diff --git a/plc4go/tests/drivers/tests/manual_ads_driver_test.go b/plc4go/tests/drivers/tests/manual_ads_driver_test.go
index c300b2881c..ea08b919b8 100644
--- a/plc4go/tests/drivers/tests/manual_ads_driver_test.go
+++ b/plc4go/tests/drivers/tests/manual_ads_driver_test.go
@@ -109,5 +109,5 @@ func TestManualAds(t *testing.T) {
 	test.AddTestCase("main.hurz_TOD:TOD", "16:17:18.123")
 	test.AddTestCase("main.hurz_DATE_AND_TIME:DATE_AND_TIME", "1996-05-06T15:36:30")
 	test.AddTestCase("main.hurz_DT:DT", "1972-03-29T00:00")
-	test.Run()
+	test.Run(t)
 }
diff --git a/plc4go/tests/drivers/tests/manual_bacnet_driver_test.go b/plc4go/tests/drivers/tests/manual_bacnet_driver_test.go
index d769c80188..504b19fcb6 100644
--- a/plc4go/tests/drivers/tests/manual_bacnet_driver_test.go
+++ b/plc4go/tests/drivers/tests/manual_bacnet_driver_test.go
@@ -22,27 +22,14 @@ package tests
 import (
 	"github.com/apache/plc4x/plc4go/internal/bacnetip"
 	"github.com/apache/plc4x/plc4go/pkg/api"
-	"github.com/apache/plc4x/plc4go/pkg/api/config"
 	"github.com/apache/plc4x/plc4go/pkg/api/transports"
 	"github.com/apache/plc4x/plc4go/spi/testutils"
 	_ "github.com/apache/plc4x/plc4go/tests/initializetest"
-	"github.com/rs/zerolog"
-	"github.com/rs/zerolog/log"
-	"github.com/rs/zerolog/pkgerrors"
-	"os"
 	"testing"
 )
 
 func TestManualBacnetDriver(t *testing.T) {
 	t.Skip()
-	zerolog.ErrorStackMarshaler = pkgerrors.MarshalStack
-	log.Logger = log.
-		With().Caller().Logger().
-		Output(zerolog.ConsoleWriter{Out: os.Stderr}).
-		Level(zerolog.DebugLevel)
-	config.TraceTransactionManagerWorkers = false
-	config.TraceTransactionManagerTransactions = false
-	config.TraceDefaultMessageCodecWorker = false
 
 	connectionString := "bacnet-ip://192.168.178.101"
 	driverManager := plc4go.NewPlcDriverManager()
@@ -53,5 +40,5 @@ func TestManualBacnetDriver(t *testing.T) {
 	test.AddTestCase("ANALOG_OUTPUT,133/PRESENT_VALUE", true)
 	test.AddTestCase("DEVICE,133/LOCATION&DESCRIPTION", true)
 
-	test.Run()
+	test.Run(t)
 }
diff --git a/plc4go/tests/drivers/tests/manual_cbus_driver_test.go b/plc4go/tests/drivers/tests/manual_cbus_driver_test.go
index 388b44fbb0..2231850595 100644
--- a/plc4go/tests/drivers/tests/manual_cbus_driver_test.go
+++ b/plc4go/tests/drivers/tests/manual_cbus_driver_test.go
@@ -21,31 +21,20 @@ package tests
 
 import (
 	"fmt"
-	"os"
 	"testing"
 	"time"
 
 	"github.com/apache/plc4x/plc4go/internal/cbus"
 	"github.com/apache/plc4x/plc4go/pkg/api"
-	"github.com/apache/plc4x/plc4go/pkg/api/config"
 	"github.com/apache/plc4x/plc4go/pkg/api/model"
 	"github.com/apache/plc4x/plc4go/pkg/api/transports"
 	"github.com/apache/plc4x/plc4go/spi/testutils"
 	"github.com/apache/plc4x/plc4go/spi/utils"
 	_ "github.com/apache/plc4x/plc4go/tests/initializetest"
-	"github.com/rs/zerolog"
-	"github.com/rs/zerolog/log"
 	"github.com/stretchr/testify/require"
 )
 
 func TestManualCBusDriverMixed(t *testing.T) {
-	log.Logger = log.
-		With().Caller().Logger().
-		Output(zerolog.ConsoleWriter{Out: os.Stderr}).
-		Level(zerolog.InfoLevel)
-	config.TraceTransactionManagerWorkers = true
-	config.TraceTransactionManagerTransactions = true
-	config.TraceDefaultMessageCodecWorker = true
 	t.Skip()
 
 	connectionString := "c-bus://192.168.178.101"
@@ -61,7 +50,7 @@ func TestManualCBusDriverMixed(t *testing.T) {
 	//test.AddTestCase("cal/0/identify=[FirmwareVersion]", true)
 	//test.AddTestCase("cal/0/gestatus=[0xFF, 1]", true)
 
-	plcConnection := test.Run()
+	plcConnection := test.Run(t)
 	t.Run("Subscription test", func(t *testing.T) {
 		gotMMI := make(chan bool)
 		gotSAL := make(chan bool)
@@ -121,13 +110,6 @@ func TestManualCBusDriverMixed(t *testing.T) {
 }
 
 func TestManualCBusBrowse(t *testing.T) {
-	log.Logger = log.
-		With().Caller().Logger().
-		Output(zerolog.ConsoleWriter{Out: os.Stderr}).
-		Level(zerolog.InfoLevel)
-	config.TraceTransactionManagerWorkers = false
-	config.TraceTransactionManagerTransactions = false
-	config.TraceDefaultMessageCodecWorker = false
 	t.Skip()
 
 	connectionString := "c-bus://192.168.178.101?Monitor=false&MonitoredApplication1=0x00&MonitoredApplication2=0x00"
@@ -155,13 +137,6 @@ func TestManualCBusBrowse(t *testing.T) {
 }
 
 func TestManualCBusRead(t *testing.T) {
-	log.Logger = log.
-		With().Caller().Logger().
-		Output(zerolog.ConsoleWriter{Out: os.Stderr}).
-		Level(zerolog.InfoLevel)
-	config.TraceTransactionManagerWorkers = false
-	config.TraceTransactionManagerTransactions = false
-	config.TraceDefaultMessageCodecWorker = false
 	t.Skip()
 
 	connectionString := "c-bus://192.168.178.101?Monitor=false&MonitoredApplication1=0x00&MonitoredApplication2=0x00"
@@ -184,13 +159,6 @@ func TestManualCBusRead(t *testing.T) {
 }
 
 func TestManualDiscovery(t *testing.T) {
-	log.Logger = log.
-		With().Caller().Logger().
-		Output(zerolog.ConsoleWriter{Out: os.Stderr}).
-		Level(zerolog.TraceLevel)
-	config.TraceTransactionManagerWorkers = false
-	config.TraceTransactionManagerTransactions = false
-	config.TraceDefaultMessageCodecWorker = false
 	t.Skip()
 
 	driverManager := plc4go.NewPlcDriverManager()
diff --git a/plc4go/tests/drivers/tests/manual_s7_driver_test.go b/plc4go/tests/drivers/tests/manual_s7_driver_test.go
index 8101338c81..835bba757b 100644
--- a/plc4go/tests/drivers/tests/manual_s7_driver_test.go
+++ b/plc4go/tests/drivers/tests/manual_s7_driver_test.go
@@ -108,5 +108,5 @@ func TestManualS7Driver(t *testing.T) {
 	test.AddTestCase("%DB4:140:STRING(10)", "hurz")
 	test.AddTestCase("%DB4:396:WSTRING(10)", "wolf")
 
-	test.Run()
+	test.Run(t)
 }
diff --git a/plc4go/tests/drivers/tests/modbus_driver_test.go b/plc4go/tests/drivers/tests/modbus_driver_test.go
index 22102d8640..45e4cbdba6 100644
--- a/plc4go/tests/drivers/tests/modbus_driver_test.go
+++ b/plc4go/tests/drivers/tests/modbus_driver_test.go
@@ -32,8 +32,8 @@ import (
 )
 
 func TestModbusDriver(t *testing.T) {
-	options := []testutils.WithOption{testutils.WithRootTypeParser(func(readBufferByteBased utils.ReadBufferByteBased) (any, error) {
+	parser := func(readBufferByteBased utils.ReadBufferByteBased) (any, error) {
 		return modbusModel.ModbusTcpADUParseWithBuffer(context.Background(), readBufferByteBased, modbusModel.DriverType_MODBUS_TCP, false)
-	})}
-	testutils.RunDriverTestsuiteWithOptions(t, modbus.NewModbusTcpDriver(), "assets/testing/protocols/modbus/tcp/DriverTestsuite.xml", modbusIO.ModbusXmlParserHelper{}, options)
+	}
+	testutils.RunDriverTestsuite(t, modbus.NewModbusTcpDriver(), "assets/testing/protocols/modbus/tcp/DriverTestsuite.xml", modbusIO.ModbusXmlParserHelper{}, testutils.WithRootTypeParser(parser))
 }
diff --git a/plc4go/tests/drivers/tests/s7_driver_test.go b/plc4go/tests/drivers/tests/s7_driver_test.go
index 381b1cd1cc..69ca1fbb4d 100644
--- a/plc4go/tests/drivers/tests/s7_driver_test.go
+++ b/plc4go/tests/drivers/tests/s7_driver_test.go
@@ -32,8 +32,8 @@ import (
 )
 
 func TestS7Driver(t *testing.T) {
-	options := []testutils.WithOption{testutils.WithRootTypeParser(func(readBufferByteBased utils.ReadBufferByteBased) (any, error) {
+	parser := func(readBufferByteBased utils.ReadBufferByteBased) (any, error) {
 		return s7Model.TPKTPacketParseWithBuffer(context.Background(), readBufferByteBased)
-	})}
-	testutils.RunDriverTestsuiteWithOptions(t, s7.NewDriver(), "assets/testing/protocols/s7/DriverTestsuite.xml", s7IO.S7XmlParserHelper{}, options)
+	}
+	testutils.RunDriverTestsuite(t, s7.NewDriver(), "assets/testing/protocols/s7/DriverTestsuite.xml", s7IO.S7XmlParserHelper{}, testutils.WithRootTypeParser(parser))
 }
diff --git a/plc4go/tests/initializetest/init.go b/plc4go/tests/initializetest/init.go
index 2155becf17..37bb014827 100644
--- a/plc4go/tests/initializetest/init.go
+++ b/plc4go/tests/initializetest/init.go
@@ -20,12 +20,19 @@
 package initializetest
 
 import (
+	"github.com/apache/plc4x/plc4go/pkg/api/config"
 	"github.com/rs/zerolog"
 	"github.com/rs/zerolog/log"
+	"github.com/rs/zerolog/pkgerrors"
 	"os"
 )
 
 func init() {
+	SetupDefaultLoggerForTest()
+}
+
+// SetupDefaultLoggerForTest This is the default log setting for Jenkins
+func SetupDefaultLoggerForTest() {
 	onJenkins := os.Getenv("JENKINS_URL") != ""
 	log.Logger = log.
 		//// Enable below if you want to see the filenames
@@ -33,3 +40,15 @@ func init() {
 		Output(zerolog.ConsoleWriter{Out: os.Stderr, NoColor: onJenkins}).
 		Level(zerolog.InfoLevel)
 }
+
+// GoFullDebug can be called to set up logger for debug (the call to this should not be committed)
+func GoFullDebug() {
+	zerolog.ErrorStackMarshaler = pkgerrors.MarshalStack
+	log.Logger = log.
+		With().Caller().Logger().
+		Output(zerolog.ConsoleWriter{Out: os.Stderr}).
+		Level(zerolog.DebugLevel)
+	config.TraceTransactionManagerWorkers = false
+	config.TraceTransactionManagerTransactions = false
+	config.TraceDefaultMessageCodecWorker = false
+}


[plc4x] 02/02: test(plc4go): refactor ParserSerializerTestRunner to align with DriverTestRunner

Posted by sr...@apache.org.
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 a3eca409ca0103afa4871131b4a7d9b9d1360135
Author: Sebastian Rühl <sr...@apache.org>
AuthorDate: Fri Apr 21 14:08:12 2023 +0200

    test(plc4go): refactor ParserSerializerTestRunner to align with DriverTestRunner
---
 plc4go/spi/testutils/DriverTestRunner.go           | 103 +++---
 plc4go/spi/testutils/ParserSerializerTestRunner.go | 402 ++++++++++++---------
 plc4go/tests/drivers/tests/abeth_driver_test.go    |   3 +-
 .../drivers/tests/abeth_parser_serializer_test.go  |   6 +-
 .../drivers/tests/ads_parser_serializer_test.go    |   6 +-
 .../drivers/tests/bacnet_parser_serializer_test.go |   6 +-
 plc4go/tests/drivers/tests/df1_driver_test.go      |   3 +-
 .../drivers/tests/df1_parser_serializer_test.go    |   6 +-
 plc4go/tests/drivers/tests/eip_driver_test.go      |   4 +-
 .../drivers/tests/eip_parser_serializer_test.go    |   5 +-
 plc4go/tests/drivers/tests/firmata_driver_test.go  |   3 +-
 .../tests/firmata_parser_serializer_test.go        |   6 +-
 .../tests/knxnetip_parser_serializer_test.go       |   6 +-
 .../tests/drivers/tests/manual_ads_driver_test.go  |   3 +-
 .../drivers/tests/manual_bacnet_PcapTest_test.go   |   6 +-
 .../drivers/tests/manual_bacnet_driver_test.go     |   3 +-
 plc4go/tests/drivers/tests/manual_bacnet_test.go   |   1 +
 .../tests/drivers/tests/manual_cbus_driver_test.go |   1 +
 .../tests/drivers/tests/manual_s7_driver_test.go   |   3 +-
 .../drivers/tests/modbus_parser_serializer_test.go |  10 +-
 .../drivers/tests/s7_parser_serializer_test.go     |   6 +-
 21 files changed, 341 insertions(+), 251 deletions(-)

diff --git a/plc4go/spi/testutils/DriverTestRunner.go b/plc4go/spi/testutils/DriverTestRunner.go
index 8bdee21151..b682814689 100644
--- a/plc4go/spi/testutils/DriverTestRunner.go
+++ b/plc4go/spi/testutils/DriverTestRunner.go
@@ -51,9 +51,9 @@ type DriverTestsuite struct {
 	byteOrder        binary.ByteOrder
 	parser           XmlParser
 	rootTypeParser   func(utils.ReadBufferByteBased) (any, error)
-	setupSteps       []TestStep
-	teardownSteps    []TestStep
-	testcases        []Testcase
+	setupSteps       []DriverTestStep
+	teardownSteps    []DriverTestStep
+	testcases        []DriverTestcase
 }
 
 type XmlParser interface {
@@ -98,7 +98,7 @@ type TestTransportInstance interface {
 	DrainWriteBuffer(numBytes uint32) []byte
 }
 
-func (m DriverTestsuite) Run(t *testing.T, driverManager plc4go.PlcDriverManager, testcase Testcase) error {
+func (m DriverTestsuite) Run(t *testing.T, driverManager plc4go.PlcDriverManager, testcase DriverTestcase) error {
 	var options []string
 	for key, value := range m.driverParameters {
 		options = append(options, fmt.Sprintf("%s=%s", key, value))
@@ -153,7 +153,7 @@ func (m DriverTestsuite) Run(t *testing.T, driverManager plc4go.PlcDriverManager
 	return nil
 }
 
-func (m DriverTestsuite) ExecuteStep(t *testing.T, connection plc4go.PlcConnection, testcase *Testcase, step TestStep) error {
+func (m DriverTestsuite) ExecuteStep(t *testing.T, connection plc4go.PlcConnection, testcase *DriverTestcase, step DriverTestStep) error {
 	mc, ok := connection.(spi.TransportInstanceExposer)
 	if !ok {
 		return errors.New("couldn't access connections transport instance")
@@ -428,7 +428,7 @@ func (m DriverTestsuite) ExecuteStep(t *testing.T, connection plc4go.PlcConnecti
 	return nil
 }
 
-func (m DriverTestsuite) parseMessage(typeName string, payloadString string, step TestStep) (any, error) {
+func (m DriverTestsuite) parseMessage(typeName string, payloadString string, step DriverTestStep) (any, error) {
 	if m.parser == nil {
 		return nil, errors.Errorf("Protocol name %s has no mapped parser", m.protocolName)
 	}
@@ -439,19 +439,14 @@ func (m DriverTestsuite) parseMessage(typeName string, payloadString string, ste
 	return parse, err
 }
 
-func (m DriverTestsuite) ParseXml(referenceXml *xmldom.Node, parserArguments []string) {
-	normalizeXml(referenceXml)
-	//referenceSerialized := referenceXml.FirstChild().XMLPretty()
-}
-
-type Testcase struct {
+type DriverTestcase struct {
 	name                      string
-	steps                     []TestStep
+	steps                     []DriverTestStep
 	readRequestResultChannel  <-chan apiModel.PlcReadRequestResult
 	writeRequestResultChannel <-chan apiModel.PlcWriteRequestResult
 }
 
-type TestStep struct {
+type DriverTestStep struct {
 	name            string
 	stepType        StepType
 	parserArguments []string
@@ -490,17 +485,10 @@ func RunDriverTestsuite(t *testing.T, driver plc4go.PlcDriver, testPath string,
 		}
 	}
 	// Read the test-specification as XML file
-	rootNode, err := ParseDriverTestsuiteXml(testPath)
-	if err != nil {
-		t.Fatal(err)
-	}
+	rootNode := ParseDriverTestsuiteXml(t, testPath)
 
 	// Parse the contents of the test-specification
-	testsuite, err := ParseDriverTestsuite(t, *rootNode, parser, rootTypeParser)
-	if err != nil {
-		t.Fatal(err)
-		return
-	}
+	testsuite := ParseDriverTestsuite(t, *rootNode, parser, rootTypeParser)
 
 	// We don't want to await completion of connection initialization
 	if connectionConnectAwaiter, ok := driver.(ConnectionConnectAwaiter); ok {
@@ -544,11 +532,11 @@ type ConnectionConnectAwaiter interface {
 	SetAwaitDisconnectComplete(awaitComplete bool)
 }
 
-func ParseDriverTestsuiteXml(testPath string) (*xmldom.Node, error) {
+func ParseDriverTestsuiteXml(t *testing.T, testPath string) *xmldom.Node {
 	// Get the current working directory
 	path, err := os.Getwd()
 	if err != nil {
-		return nil, err
+		t.Fatal(err)
 	}
 
 	// Check if the test-file is available
@@ -556,26 +544,29 @@ func ParseDriverTestsuiteXml(testPath string) (*xmldom.Node, error) {
 	testSuitePath := path + pathOffset + testPath
 	info, err := os.Stat(testSuitePath)
 	if os.IsNotExist(err) {
-		return nil, errors.Wrap(err, "test-File doesn't exist")
+		t.Logf("Test-File %s doesn't exist", testSuitePath)
+		t.Fatal(err)
 	}
 	if info.IsDir() {
-		return nil, errors.New("test-file refers to a directory")
+		t.Logf("Test-File %s refers to a directory", testSuitePath)
+		t.Fatal(err)
 	}
 
 	// Open a reader for this file
 	dat, err := os.Open(testSuitePath)
 	if err != nil {
-		return nil, errors.Wrap(err, "error opening file")
+		t.Log("error opening file")
+		t.Fatal(err)
 	}
 
 	// Read the xml
 	node := xmldom.Must(xmldom.Parse(dat)).Root
-	return node, nil
+	return node
 }
 
-func ParseDriverTestsuite(t *testing.T, node xmldom.Node, parser XmlParser, rootTypeParser func(utils.ReadBufferByteBased) (any, error)) (*DriverTestsuite, error) {
+func ParseDriverTestsuite(t *testing.T, node xmldom.Node, parser XmlParser, rootTypeParser func(utils.ReadBufferByteBased) (any, error)) *DriverTestsuite {
 	if node.Name != "driver-testsuite" {
-		return nil, errors.New("invalid document structure")
+		t.Fatal("invalid document structure")
 	}
 	var byteOrder binary.ByteOrder
 	if node.GetAttributeValue("byteOrder") != "LITTLE_ENDIAN" {
@@ -588,60 +579,64 @@ func ParseDriverTestsuite(t *testing.T, node xmldom.Node, parser XmlParser, root
 	var outputFlavor string
 	var driverName string
 	driverParameters := make(map[string]string)
-	var setupSteps []TestStep
-	var teardownSteps []TestStep
-	var testcases []Testcase
+	var setupSteps []DriverTestStep
+	var teardownSteps []DriverTestStep
+	var testcases []DriverTestcase
 	for _, childPtr := range node.Children {
 		child := *childPtr
-		if child.Name == "name" {
+		switch child.Name {
+		case "name":
 			testsuiteName = child.Text
-		} else if child.Name == "protocolName" {
+		case "protocolName":
 			protocolName = child.Text
-		} else if child.Name == "outputFlavor" {
+		case "outputFlavor":
 			outputFlavor = child.Text
-		} else if child.Name == "driver-name" {
+		case "driver-name":
 			driverName = child.Text
-		} else if child.Name == "driver-parameters" {
+		case "driver-parameters":
 			parameterList := child.FindByName("parameter")
 			for _, parameter := range parameterList {
 				nameElement := parameter.FindOneByName("name")
 				valueElement := parameter.FindOneByName("value")
 				if nameElement == nil || valueElement == nil {
-					return nil, errors.New("invalid parameter found: no present")
+					t.Fatal("invalid parameter found: no present")
 				}
 				name := nameElement.Text
 				value := valueElement.Text
 				if name == "" || value == "" {
-					return nil, errors.New("invalid parameter found: empty")
+					t.Fatal("invalid parameter found: empty")
 				}
 				driverParameters[name] = value
 			}
-		} else if child.Name == "setup" {
+		case "setup":
 			steps, err := ParseDriverTestsuiteSteps(t, child)
 			if err != nil {
-				return nil, errors.Wrap(err, "error parsing setup steps")
+				t.Error("error parsing setup steps")
+				t.Fatal(err)
 			}
 			setupSteps = steps
-		} else if child.Name == "teardown" {
+		case "teardown":
 			steps, err := ParseDriverTestsuiteSteps(t, child)
 			if err != nil {
-				return nil, errors.Wrap(err, "error teardown setup steps")
+				t.Error("error parsing teardown steps")
+				t.Fatal(err)
 			}
 			teardownSteps = steps
-		} else if child.Name == "testcase" {
+		case "testcase":
 			testcaseName := child.FindOneByName("name").Text
 			stepsNode := child.FindOneByName("steps")
 			steps, err := ParseDriverTestsuiteSteps(t, *stepsNode)
 			if err != nil {
-				return nil, errors.Wrap(err, "error parsing testcase "+testcaseName)
+				t.Errorf("error parsing testcase %s", testcaseName)
+				t.Fatal(err)
 			}
-			testcase := Testcase{
+			testcase := DriverTestcase{
 				name:  testcaseName,
 				steps: steps,
 			}
 			testcases = append(testcases, testcase)
-		} else {
-			return nil, errors.New("invalid document structure. Unhandled element " + child.Name)
+		default:
+			t.Fatalf("invalid document structure. Unhandled element %s", child.Name)
 		}
 	}
 	t.Logf("Parsed testsuite name: %s, driver name: %s", testsuiteName, driverName)
@@ -658,12 +653,12 @@ func ParseDriverTestsuite(t *testing.T, node xmldom.Node, parser XmlParser, root
 		setupSteps:       setupSteps,
 		teardownSteps:    teardownSteps,
 		testcases:        testcases,
-	}, nil
+	}
 }
 
-func ParseDriverTestsuiteSteps(t *testing.T, node xmldom.Node) ([]TestStep, error) {
+func ParseDriverTestsuiteSteps(t *testing.T, node xmldom.Node) ([]DriverTestStep, error) {
 	t.Logf("Parsing driver testsuite steps (rootElement %s)", node.Name)
-	var testSteps []TestStep
+	var testSteps []DriverTestStep
 	for _, step := range node.Children {
 		name := step.GetAttributeValue("name")
 		t.Logf("Parsing step (name: %s, rootElement %s)", name, node.Name)
@@ -709,7 +704,7 @@ func ParseDriverTestsuiteSteps(t *testing.T, node xmldom.Node) ([]TestStep, erro
 		if payload == nil {
 			return nil, errors.New("missing payload element")
 		}
-		testSteps = append(testSteps, TestStep{
+		testSteps = append(testSteps, DriverTestStep{
 			name:            name,
 			stepType:        stepType,
 			parserArguments: parserArguments,
diff --git a/plc4go/spi/testutils/ParserSerializerTestRunner.go b/plc4go/spi/testutils/ParserSerializerTestRunner.go
index c0fbec8e21..9676a230a0 100644
--- a/plc4go/spi/testutils/ParserSerializerTestRunner.go
+++ b/plc4go/spi/testutils/ParserSerializerTestRunner.go
@@ -25,34 +25,192 @@ import (
 	"encoding/hex"
 	"fmt"
 	"os"
+	"runtime/debug"
 	"strconv"
 	"strings"
 	"testing"
 
-	abethModel "github.com/apache/plc4x/plc4go/protocols/abeth/readwrite"
-	adsModel "github.com/apache/plc4x/plc4go/protocols/ads/readwrite"
-	bacnetModel "github.com/apache/plc4x/plc4go/protocols/bacnetip/readwrite"
-	df1Model "github.com/apache/plc4x/plc4go/protocols/df1/readwrite"
-	eipModel "github.com/apache/plc4x/plc4go/protocols/eip/readwrite"
-	firmataModel "github.com/apache/plc4x/plc4go/protocols/firmata/readwrite"
-	knxModel "github.com/apache/plc4x/plc4go/protocols/knxnetip/readwrite"
-	modbusModel "github.com/apache/plc4x/plc4go/protocols/modbus/readwrite"
-	s7Model "github.com/apache/plc4x/plc4go/protocols/s7/readwrite"
 	"github.com/apache/plc4x/plc4go/spi/utils"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/subchen/go-xmldom"
 )
 
-func RunParserSerializerTestsuite(t *testing.T, testPath string, skippedTestCases ...string) {
+type ParserSerializerTestsuite struct {
+	name             string
+	protocolName     string
+	outputFlavor     string
+	driverParameters map[string]string
+	byteOrder        binary.ByteOrder
+	parser           Parser
+	rootTypeParser   func(utils.ReadBufferByteBased) (any, error)
+	testcases        []ParserSerializerTestcase
+}
+
+type ParserSerializerTestcase struct {
+	name            string
+	rawInputText    string
+	rootType        string
+	referenceXml    string
+	parserArguments []string
+}
+
+func (p *ParserSerializerTestsuite) Run(t *testing.T, testcase ParserSerializerTestcase) error {
+	t.Run(testcase.name, func(t *testing.T) {
+		t.Logf("running testsuite: %s test: %s", p.name, testcase.name)
+
+		// Get the raw input by decoding the hex-encoded binary input
+		rawInput, err := hex.DecodeString(testcase.rawInputText)
+		if err != nil {
+			t.Errorf("Error decoding test input")
+			return
+		}
+		var readBuffer utils.ReadBuffer
+		if p.byteOrder == binary.LittleEndian {
+			readBuffer = utils.NewReadBufferByteBased(rawInput, utils.WithByteOrderForReadBufferByteBased(binary.LittleEndian))
+		} else {
+			readBuffer = utils.NewReadBufferByteBased(rawInput)
+		}
+
+		// Parse the input according to the settings of the testcase
+		msg, err := p.parser.Parse(testcase.rootType, testcase.parserArguments, readBuffer)
+		if err != nil {
+			t.Error("Error parsing input data: ", err)
+			return
+		}
+
+		{
+			// First try to use the native xml writer
+			serializable := msg.(utils.Serializable)
+			buffer := utils.NewXmlWriteBuffer()
+			if err := serializable.SerializeWithWriteBuffer(context.Background(), buffer); err == nil {
+				actualXml := buffer.GetXmlString()
+				if err := CompareResults(t, []byte(actualXml), []byte(testcase.referenceXml)); err != nil {
+					border := strings.Repeat("=", 100)
+					fmt.Printf(
+						"\n"+
+							// Border
+							"%[1]s\n"+
+							// Testcase name
+							"%[4]s\n"+
+							// diff detected message
+							"Diff detected\n"+
+							// Border
+							"%[1]s\n"+
+							// xml
+							"%[2]s\n"+
+							// Border
+							"%[1]s\n%[1]s\n"+
+							// Text
+							"Differences were found after parsing (Use the above xml in the testsuite to disable this warning).\n"+
+							// Diff
+							"%[3]s\n"+
+							// Double Border
+							"%[1]s\n%[1]s\n",
+						border,
+						actualXml,
+						err,
+						testcase.name)
+					assert.Equal(t, testcase.referenceXml, actualXml)
+					t.Error("Error comparing the results: " + err.Error())
+					return
+				}
+			}
+		}
+
+		// If all was ok, serialize the object again
+		s, ok := msg.(utils.Serializable)
+		if !ok {
+			t.Error("Couldn't cast message to Serializable")
+			return
+		}
+		var writeBuffer utils.WriteBufferByteBased
+		if p.byteOrder == binary.LittleEndian {
+			writeBuffer = utils.NewWriteBufferByteBased(utils.WithByteOrderForByteBasedBuffer(binary.LittleEndian))
+		} else {
+			writeBuffer = utils.NewWriteBufferByteBased()
+		}
+		err = s.SerializeWithWriteBuffer(context.Background(), writeBuffer)
+		if !ok {
+			t.Error("Couldn't serialize message back to byte array")
+			return
+		}
+
+		// Check if the output matches in size and content
+		rawOutput := writeBuffer.GetBytes()
+		if len(rawInput) != len(rawOutput) {
+			t.Errorf("Missmatched number of bytes expected ->%d != %d<-actual\nexpected:\t%x\nactual:\t\t%x", len(rawInput), len(rawOutput), rawInput, rawOutput)
+			t.Errorf("Hexdumps:\n%s", utils.DiffHex(rawInput, rawOutput))
+			return
+		}
+		for i, val := range rawInput {
+			if rawOutput[i] != val {
+				t.Error("Raw output doesn't match input at position: " + strconv.Itoa(i))
+				t.Errorf("Hexdumps:\n%s", utils.DiffHex(rawInput, rawOutput))
+				return
+			}
+		}
+	})
+	return nil
+}
+
+type Parser interface {
+	Parse(typeName string, arguments []string, io utils.ReadBuffer) (any, error)
+}
+
+func RunParserSerializerTestsuite(t *testing.T, testPath string, parser Parser, options ...WithOption) {
+	t.Log("Extract testsuite options")
+	var rootTypeParser func(utils.ReadBufferByteBased) (any, error)
 	skippedTestCasesMap := map[string]bool{}
-	for _, skippedTestCase := range skippedTestCases {
-		skippedTestCasesMap[skippedTestCase] = true
+	for _, withOption := range options {
+		switch option := withOption.(type) {
+		case withRootTypeParser:
+			t.Logf("Using root type parser for better output")
+			rootTypeParser = option.rootTypeParser
+		case withSkippedTestCases:
+			t.Log("Skipping test cases:")
+			for _, skippedTestCase := range option.skippedTestCases {
+				t.Logf("Skipping %s", skippedTestCase)
+				skippedTestCasesMap[skippedTestCase] = true
+			}
+		}
+	}
+
+	// Read the test-specification as XML file
+	rootNode := ParseParserSerializerTestSuiteXml(t, testPath)
+
+	// Parse the contents of the test-specification
+	testsuite := ParseParserSerializerTestSuite(t, *rootNode, parser, rootTypeParser)
+
+	t.Logf("Running %d testcases", len(testsuite.testcases))
+	for _, testcase := range testsuite.testcases {
+		t.Run(testcase.name, func(t *testing.T) {
+			defer func() {
+				if err := recover(); err != nil {
+					t.Fatalf("\n-------------------------------------------------------\nPanic Failure\n%+v\n%s\n-------------------------------------------------------\n\n", err, debug.Stack())
+				}
+			}()
+			if skippedTestCasesMap[testcase.name] {
+				t.Logf("Testcase %s skipped", testcase.name)
+				t.Skipf("Testcase %s skipped", testcase.name)
+				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)
+			}
+		})
 	}
+	t.Log("Done running testcases")
+	// Execute the tests in the testsuite
+	t.Logf(testsuite.name)
+}
+
+func ParseParserSerializerTestSuiteXml(t *testing.T, testPath string) *xmldom.Node {
 	// Get the current working directory
 	path, err := os.Getwd()
 	if err != nil {
-		t.Error(err)
+		t.Fatal(err)
 	}
 
 	// Check if the test-file is available
@@ -60,10 +218,12 @@ func RunParserSerializerTestsuite(t *testing.T, testPath string, skippedTestCase
 	testFile := path + dirOffset + testPath
 	info, err := os.Stat(testFile)
 	if os.IsNotExist(err) {
-		t.Errorf("Test-File %s doesn't exist", testFile)
+		t.Logf("Test-File %s doesn't exist", testFile)
+		t.Fatal(err)
 	}
 	if info.IsDir() {
-		t.Errorf("Test-File %s refers to a directory", testFile)
+		t.Logf("Test-File %s refers to a directory", testFile)
+		t.Fatal(err)
 	}
 
 	// Open a reader for this file
@@ -74,9 +234,12 @@ func RunParserSerializerTestsuite(t *testing.T, testPath string, skippedTestCase
 
 	// Read the xml
 	node := xmldom.Must(xmldom.Parse(dat)).Root
+	return node
+}
 
+func ParseParserSerializerTestSuite(t *testing.T, node xmldom.Node, parser Parser, rootTypeParser func(utils.ReadBufferByteBased) (any, error)) *ParserSerializerTestsuite {
 	if node.Name != "testsuite" {
-		t.Error("Invalid document structure")
+		t.Fatal("invalid document structure")
 	}
 	var byteOrder binary.ByteOrder
 	if node.GetAttributeValue("byteOrder") != "LITTLE_ENDIAN" {
@@ -84,166 +247,73 @@ func RunParserSerializerTestsuite(t *testing.T, testPath string, skippedTestCase
 	} else {
 		byteOrder = binary.LittleEndian
 	}
-	var (
-		testsuiteName string
-		protocolName  string
-		outputFlavor  string
-	)
+	var testsuiteName string
+	var protocolName string
+	var outputFlavor string
+	driverParameters := make(map[string]string)
+	var testcases []ParserSerializerTestcase
 	for _, childPtr := range node.Children {
 		child := *childPtr
-		if child.Name == "name" {
+		switch child.Name {
+		case "name":
 			testsuiteName = child.Text
-		} else if child.Name == "protocolName" {
+		case "protocolName":
 			protocolName = child.Text
-		} else if child.Name == "outputFlavor" {
+		case "outputFlavor":
 			outputFlavor = child.Text
-		} else if child.Name != "testcase" {
-			t.Error("Invalid document structure")
-			return
-		} else {
-			testCaseName := child.FindOneByName("name").Text
-			t.Run(testCaseName, func(t *testing.T) {
-				if skippedTestCasesMap[testCaseName] {
-					t.Logf("Testcase %s skipped", testCaseName)
-					t.Skipf("Testcase %s skipped", testCaseName)
-					return
-				}
-				t.Logf("running testsuite: %s test: %s", testsuiteName, testCaseName)
-				rawInputText := (*(child.FindOneByName("raw"))).Text
-				rootType := (*(child.FindOneByName("root-type"))).Text
-				parserArgumentsXml := child.FindOneByName("parser-arguments")
-				var parserArguments []string
-				if parserArgumentsXml != nil {
-					for _, parserArgumentXml := range parserArgumentsXml.Children {
-						parserArguments = append(parserArguments, parserArgumentXml.Text)
-					}
-				}
-				referenceXml := child.FindOneByName("xml")
-				normalizeXml(referenceXml)
-				referenceSerialized := referenceXml.FirstChild().XMLPretty()
-
-				// Get the raw input by decoding the hex-encoded binary input
-				rawInput, err := hex.DecodeString(rawInputText)
-				if err != nil {
-					t.Errorf("Error decoding test input")
-					return
-				}
-				var readBuffer utils.ReadBuffer
-				if byteOrder == binary.LittleEndian {
-					readBuffer = utils.NewReadBufferByteBased(rawInput, utils.WithByteOrderForReadBufferByteBased(binary.LittleEndian))
-				} else {
-					readBuffer = utils.NewReadBufferByteBased(rawInput)
+		case "driver-parameters":
+			parameterList := child.FindByName("parameter")
+			for _, parameter := range parameterList {
+				nameElement := parameter.FindOneByName("name")
+				valueElement := parameter.FindOneByName("value")
+				if nameElement == nil || valueElement == nil {
+					t.Fatal("invalid parameter found: no present")
 				}
-
-				// Parse the input according to the settings of the testcase
-				var helper interface {
-					Parse(typeName string, arguments []string, io utils.ReadBuffer) (any, error)
+				name := nameElement.Text
+				value := valueElement.Text
+				if name == "" || value == "" {
+					t.Fatal("invalid parameter found: empty")
 				}
-				switch protocolName {
-				case "abeth":
-					helper = new(abethModel.AbethParserHelper)
-				case "ads":
-					helper = new(adsModel.AdsParserHelper)
-				case "bacnetip":
-					helper = new(bacnetModel.BacnetipParserHelper)
-				case "df1":
-					helper = new(df1Model.Df1ParserHelper)
-				case "eip":
-					helper = new(eipModel.EipParserHelper)
-				case "firmata":
-					helper = new(firmataModel.FirmataParserHelper)
-				case "modbus":
-					helper = new(modbusModel.ModbusParserHelper)
-				case "s7":
-					helper = new(s7Model.S7ParserHelper)
-				case "knxnetip":
-					helper = new(knxModel.KnxnetipParserHelper)
-				default:
-					t.Errorf("Testsuite %s has not mapped parser for %s", testsuiteName, protocolName)
-					return
+				driverParameters[name] = value
+			}
+		case "testcase":
+			testcaseName := child.FindOneByName("name").Text
+			rawInputText := (*(child.FindOneByName("raw"))).Text
+			rootType := (*(child.FindOneByName("root-type"))).Text
+			parserArgumentsXml := child.FindOneByName("parser-arguments")
+			var parserArguments []string
+			if parserArgumentsXml != nil {
+				for _, parserArgumentXml := range parserArgumentsXml.Children {
+					parserArguments = append(parserArguments, parserArgumentXml.Text)
 				}
-				_ = outputFlavor
-				msg, err := helper.Parse(rootType, parserArguments, readBuffer)
-				if err != nil {
-					t.Error("Error parsing input data: ", err)
-					return
-				}
-
-				{
-					// First try to use the native xml writer
-					serializable := msg.(utils.Serializable)
-					buffer := utils.NewXmlWriteBuffer()
-					if err := serializable.SerializeWithWriteBuffer(context.Background(), buffer); err == nil {
-						actualXml := buffer.GetXmlString()
-						if err := CompareResults(t, []byte(actualXml), []byte(referenceSerialized)); err != nil {
-							border := strings.Repeat("=", 100)
-							fmt.Printf(
-								"\n"+
-									// Border
-									"%[1]s\n"+
-									// Testcase name
-									"%[4]s\n"+
-									// diff detected message
-									"Diff detected\n"+
-									// Border
-									"%[1]s\n"+
-									// xml
-									"%[2]s\n"+
-									// Border
-									"%[1]s\n%[1]s\n"+
-									// Text
-									"Differences were found after parsing (Use the above xml in the testsuite to disable this warning).\n"+
-									// Diff
-									"%[3]s\n"+
-									// Double Border
-									"%[1]s\n%[1]s\n",
-								border,
-								actualXml,
-								err,
-								testCaseName)
-							assert.Equal(t, referenceSerialized, actualXml)
-							t.Error("Error comparing the results: " + err.Error())
-							return
-						}
-					}
-				}
-
-				// If all was ok, serialize the object again
-				s, ok := msg.(utils.Serializable)
-				if !ok {
-					t.Error("Couldn't cast message to Serializable")
-					return
-				}
-				var writeBuffer utils.WriteBufferByteBased
-				if byteOrder == binary.LittleEndian {
-					writeBuffer = utils.NewWriteBufferByteBased(utils.WithByteOrderForByteBasedBuffer(binary.LittleEndian))
-				} else {
-					writeBuffer = utils.NewWriteBufferByteBased()
-				}
-				err = s.SerializeWithWriteBuffer(context.Background(), writeBuffer)
-				if !ok {
-					t.Error("Couldn't serialize message back to byte array")
-					return
-				}
-
-				// Check if the output matches in size and content
-				rawOutput := writeBuffer.GetBytes()
-				if len(rawInput) != len(rawOutput) {
-					t.Errorf("Missmatched number of bytes expected ->%d != %d<-actual\nexpected:\t%x\nactual:\t\t%x", len(rawInput), len(rawOutput), rawInput, rawOutput)
-					t.Errorf("Hexdumps:\n%s", utils.DiffHex(rawInput, rawOutput))
-					return
-				}
-				for i, val := range rawInput {
-					if rawOutput[i] != val {
-						t.Error("Raw output doesn't match input at position: " + strconv.Itoa(i))
-						t.Errorf("Hexdumps:\n%s", utils.DiffHex(rawInput, rawOutput))
-						return
-					}
-				}
-			})
+			}
+			referenceXml := child.FindOneByName("xml")
+			normalizeXml(referenceXml)
+			referenceSerialized := referenceXml.FirstChild().XMLPretty()
+			testcase := ParserSerializerTestcase{
+				name:            testcaseName,
+				rawInputText:    rawInputText,
+				rootType:        rootType,
+				referenceXml:    referenceSerialized,
+				parserArguments: parserArguments,
+			}
+			testcases = append(testcases, testcase)
+		default:
+			t.Fatalf("invalid document structure. Unhandled element %s", child.Name)
 		}
 	}
-	fmt.Printf("name = %v\n", node.Name)
+	t.Logf("Parsed testsuite name: %s", testsuiteName)
+
+	return &ParserSerializerTestsuite{
+		name:             testsuiteName,
+		protocolName:     protocolName,
+		outputFlavor:     outputFlavor,
+		driverParameters: driverParameters,
+		byteOrder:        byteOrder,
+		parser:           parser,
+		rootTypeParser:   rootTypeParser,
+		testcases:        testcases,
+	}
 }
 
 // Mainly remove linebreaks from text content.
diff --git a/plc4go/tests/drivers/tests/abeth_driver_test.go b/plc4go/tests/drivers/tests/abeth_driver_test.go
index 42a6ff017f..0e711567a6 100644
--- a/plc4go/tests/drivers/tests/abeth_driver_test.go
+++ b/plc4go/tests/drivers/tests/abeth_driver_test.go
@@ -20,11 +20,12 @@
 package tests
 
 import (
+	"testing"
+
 	"github.com/apache/plc4x/plc4go/internal/ads"
 	abethIO "github.com/apache/plc4x/plc4go/protocols/abeth/readwrite"
 	"github.com/apache/plc4x/plc4go/spi/testutils"
 	_ "github.com/apache/plc4x/plc4go/tests/initializetest"
-	"testing"
 )
 
 func TestAbEthDriver(t *testing.T) {
diff --git a/plc4go/tests/drivers/tests/abeth_parser_serializer_test.go b/plc4go/tests/drivers/tests/abeth_parser_serializer_test.go
index ede6265680..a640be1398 100644
--- a/plc4go/tests/drivers/tests/abeth_parser_serializer_test.go
+++ b/plc4go/tests/drivers/tests/abeth_parser_serializer_test.go
@@ -20,11 +20,13 @@
 package tests
 
 import (
+	"testing"
+
+	abethIO "github.com/apache/plc4x/plc4go/protocols/abeth/readwrite"
 	"github.com/apache/plc4x/plc4go/spi/testutils"
 	_ "github.com/apache/plc4x/plc4go/tests/initializetest"
-	"testing"
 )
 
 func TestAbEthParserSerializer(t *testing.T) {
-	testutils.RunParserSerializerTestsuite(t, "assets/testing/protocols/abeth/ParserSerializerTestsuite.xml")
+	testutils.RunParserSerializerTestsuite(t, "assets/testing/protocols/abeth/ParserSerializerTestsuite.xml", abethIO.AbethParserHelper{})
 }
diff --git a/plc4go/tests/drivers/tests/ads_parser_serializer_test.go b/plc4go/tests/drivers/tests/ads_parser_serializer_test.go
index c1e87a3610..2822693f0b 100644
--- a/plc4go/tests/drivers/tests/ads_parser_serializer_test.go
+++ b/plc4go/tests/drivers/tests/ads_parser_serializer_test.go
@@ -20,11 +20,13 @@
 package tests
 
 import (
+	"testing"
+
+	adsIO "github.com/apache/plc4x/plc4go/protocols/ads/readwrite"
 	"github.com/apache/plc4x/plc4go/spi/testutils"
 	_ "github.com/apache/plc4x/plc4go/tests/initializetest"
-	"testing"
 )
 
 func TestAdsParserSerializer(t *testing.T) {
-	testutils.RunParserSerializerTestsuite(t, "assets/testing/protocols/ads/ParserSerializerTestsuite.xml")
+	testutils.RunParserSerializerTestsuite(t, "assets/testing/protocols/ads/ParserSerializerTestsuite.xml", adsIO.AdsParserHelper{})
 }
diff --git a/plc4go/tests/drivers/tests/bacnet_parser_serializer_test.go b/plc4go/tests/drivers/tests/bacnet_parser_serializer_test.go
index 9601d90028..2340459380 100644
--- a/plc4go/tests/drivers/tests/bacnet_parser_serializer_test.go
+++ b/plc4go/tests/drivers/tests/bacnet_parser_serializer_test.go
@@ -20,11 +20,13 @@
 package tests
 
 import (
+	"testing"
+
+	bacnetIO "github.com/apache/plc4x/plc4go/protocols/bacnetip/readwrite"
 	"github.com/apache/plc4x/plc4go/spi/testutils"
 	_ "github.com/apache/plc4x/plc4go/tests/initializetest"
-	"testing"
 )
 
 func TestBacnetParserSerializer(t *testing.T) {
-	testutils.RunParserSerializerTestsuite(t, "assets/testing/protocols/bacnet/ParserSerializerTestsuite.xml")
+	testutils.RunParserSerializerTestsuite(t, "assets/testing/protocols/bacnet/ParserSerializerTestsuite.xml", bacnetIO.BacnetipParserHelper{})
 }
diff --git a/plc4go/tests/drivers/tests/df1_driver_test.go b/plc4go/tests/drivers/tests/df1_driver_test.go
index 18fc701d5e..66a68aafb1 100644
--- a/plc4go/tests/drivers/tests/df1_driver_test.go
+++ b/plc4go/tests/drivers/tests/df1_driver_test.go
@@ -20,11 +20,12 @@
 package tests
 
 import (
+	"testing"
+
 	"github.com/apache/plc4x/plc4go/internal/ads"
 	df1IO "github.com/apache/plc4x/plc4go/protocols/df1/readwrite"
 	"github.com/apache/plc4x/plc4go/spi/testutils"
 	_ "github.com/apache/plc4x/plc4go/tests/initializetest"
-	"testing"
 )
 
 func TestDf1Driver(t *testing.T) {
diff --git a/plc4go/tests/drivers/tests/df1_parser_serializer_test.go b/plc4go/tests/drivers/tests/df1_parser_serializer_test.go
index 57b4f42756..480387a3a5 100644
--- a/plc4go/tests/drivers/tests/df1_parser_serializer_test.go
+++ b/plc4go/tests/drivers/tests/df1_parser_serializer_test.go
@@ -20,12 +20,14 @@
 package tests
 
 import (
+	"testing"
+
+	df1IO "github.com/apache/plc4x/plc4go/protocols/df1/readwrite"
 	"github.com/apache/plc4x/plc4go/spi/testutils"
 	_ "github.com/apache/plc4x/plc4go/tests/initializetest"
-	"testing"
 )
 
 func TestDf1ParserSerializer(t *testing.T) {
 	//t.Skip("Still a WIP")
-	testutils.RunParserSerializerTestsuite(t, "assets/testing/protocols/df1/ParserSerializerTestsuite.xml")
+	testutils.RunParserSerializerTestsuite(t, "assets/testing/protocols/df1/ParserSerializerTestsuite.xml", df1IO.Df1ParserHelper{})
 }
diff --git a/plc4go/tests/drivers/tests/eip_driver_test.go b/plc4go/tests/drivers/tests/eip_driver_test.go
index 0ff38bf35f..1de81c8630 100644
--- a/plc4go/tests/drivers/tests/eip_driver_test.go
+++ b/plc4go/tests/drivers/tests/eip_driver_test.go
@@ -23,7 +23,7 @@ import (
 	"testing"
 
 	"github.com/apache/plc4x/plc4go/internal/eip"
-	"github.com/apache/plc4x/plc4go/protocols/eip/readwrite"
+	eipIO "github.com/apache/plc4x/plc4go/protocols/eip/readwrite"
 	"github.com/apache/plc4x/plc4go/spi/testutils"
 	_ "github.com/apache/plc4x/plc4go/tests/initializetest"
 )
@@ -36,5 +36,5 @@ func TestEIPDriver(t *testing.T) {
 	config.TraceTransactionManagerWorkers = true
 	config.TraceTransactionManagerTransactions = true
 	config.TraceDefaultMessageCodecWorker = true*/
-	testutils.RunDriverTestsuite(t, eip.NewDriver(), "assets/testing/protocols/eip/DriverTestsuite.xml", readwrite.EipXmlParserHelper{})
+	testutils.RunDriverTestsuite(t, eip.NewDriver(), "assets/testing/protocols/eip/DriverTestsuite.xml", eipIO.EipXmlParserHelper{})
 }
diff --git a/plc4go/tests/drivers/tests/eip_parser_serializer_test.go b/plc4go/tests/drivers/tests/eip_parser_serializer_test.go
index f88eb5dacd..daa1ae4232 100644
--- a/plc4go/tests/drivers/tests/eip_parser_serializer_test.go
+++ b/plc4go/tests/drivers/tests/eip_parser_serializer_test.go
@@ -22,14 +22,15 @@ package tests
 import (
 	"testing"
 
+	eipIO "github.com/apache/plc4x/plc4go/protocols/eip/readwrite"
 	"github.com/apache/plc4x/plc4go/spi/testutils"
 	_ "github.com/apache/plc4x/plc4go/tests/initializetest"
 )
 
 func TestEipParserSerializerBigEndian(t *testing.T) {
-	testutils.RunParserSerializerTestsuite(t, "assets/testing/protocols/eip/ParserSerializerTestsuiteBigEndian.xml")
+	testutils.RunParserSerializerTestsuite(t, "assets/testing/protocols/eip/ParserSerializerTestsuiteBigEndian.xml", eipIO.EipParserHelper{})
 }
 
 func TestEipParserSerializerLittleEndian(t *testing.T) {
-	testutils.RunParserSerializerTestsuite(t, "assets/testing/protocols/eip/ParserSerializerTestsuiteLittleEndian.xml")
+	testutils.RunParserSerializerTestsuite(t, "assets/testing/protocols/eip/ParserSerializerTestsuiteLittleEndian.xml", eipIO.EipParserHelper{})
 }
diff --git a/plc4go/tests/drivers/tests/firmata_driver_test.go b/plc4go/tests/drivers/tests/firmata_driver_test.go
index b1f2acc1c2..51978054d9 100644
--- a/plc4go/tests/drivers/tests/firmata_driver_test.go
+++ b/plc4go/tests/drivers/tests/firmata_driver_test.go
@@ -20,11 +20,12 @@
 package tests
 
 import (
+	"testing"
+
 	"github.com/apache/plc4x/plc4go/internal/knxnetip"
 	firmataIO "github.com/apache/plc4x/plc4go/protocols/firmata/readwrite"
 	"github.com/apache/plc4x/plc4go/spi/testutils"
 	_ "github.com/apache/plc4x/plc4go/tests/initializetest"
-	"testing"
 )
 
 func TestFirmataDriver(t *testing.T) {
diff --git a/plc4go/tests/drivers/tests/firmata_parser_serializer_test.go b/plc4go/tests/drivers/tests/firmata_parser_serializer_test.go
index f561aa1b46..24f887d13e 100644
--- a/plc4go/tests/drivers/tests/firmata_parser_serializer_test.go
+++ b/plc4go/tests/drivers/tests/firmata_parser_serializer_test.go
@@ -20,11 +20,13 @@
 package tests
 
 import (
+	"testing"
+
+	firmataIO "github.com/apache/plc4x/plc4go/protocols/firmata/readwrite"
 	"github.com/apache/plc4x/plc4go/spi/testutils"
 	_ "github.com/apache/plc4x/plc4go/tests/initializetest"
-	"testing"
 )
 
 func TestFirmataParserSerializer(t *testing.T) {
-	testutils.RunParserSerializerTestsuite(t, "assets/testing/protocols/firmata/ParserSerializerTestsuite.xml")
+	testutils.RunParserSerializerTestsuite(t, "assets/testing/protocols/firmata/ParserSerializerTestsuite.xml", firmataIO.FirmataParserHelper{})
 }
diff --git a/plc4go/tests/drivers/tests/knxnetip_parser_serializer_test.go b/plc4go/tests/drivers/tests/knxnetip_parser_serializer_test.go
index 1f7a693953..a8baa531a1 100644
--- a/plc4go/tests/drivers/tests/knxnetip_parser_serializer_test.go
+++ b/plc4go/tests/drivers/tests/knxnetip_parser_serializer_test.go
@@ -20,11 +20,13 @@
 package tests
 
 import (
+	"testing"
+
+	knxIO "github.com/apache/plc4x/plc4go/protocols/knxnetip/readwrite"
 	"github.com/apache/plc4x/plc4go/spi/testutils"
 	_ "github.com/apache/plc4x/plc4go/tests/initializetest"
-	"testing"
 )
 
 func TestKNXNetIPParserSerializer(t *testing.T) {
-	testutils.RunParserSerializerTestsuite(t, "assets/testing/protocols/knxnetip/ParserSerializerTestsuite.xml")
+	testutils.RunParserSerializerTestsuite(t, "assets/testing/protocols/knxnetip/ParserSerializerTestsuite.xml", knxIO.KnxnetipParserHelper{})
 }
diff --git a/plc4go/tests/drivers/tests/manual_ads_driver_test.go b/plc4go/tests/drivers/tests/manual_ads_driver_test.go
index ea08b919b8..26285c7d58 100644
--- a/plc4go/tests/drivers/tests/manual_ads_driver_test.go
+++ b/plc4go/tests/drivers/tests/manual_ads_driver_test.go
@@ -21,12 +21,13 @@ package tests
 
 import (
 	"fmt"
+	"testing"
+
 	"github.com/apache/plc4x/plc4go/internal/ads"
 	"github.com/apache/plc4x/plc4go/pkg/api"
 	"github.com/apache/plc4x/plc4go/pkg/api/transports"
 	"github.com/apache/plc4x/plc4go/spi/testutils"
 	_ "github.com/apache/plc4x/plc4go/tests/initializetest"
-	"testing"
 )
 
 func TestManualAds(t *testing.T) {
diff --git a/plc4go/tests/drivers/tests/manual_bacnet_PcapTest_test.go b/plc4go/tests/drivers/tests/manual_bacnet_PcapTest_test.go
index e0f0533625..bc4ca8b6c4 100644
--- a/plc4go/tests/drivers/tests/manual_bacnet_PcapTest_test.go
+++ b/plc4go/tests/drivers/tests/manual_bacnet_PcapTest_test.go
@@ -34,7 +34,7 @@ import (
 	"github.com/apache/plc4x/plc4go/pkg/api/model"
 	"github.com/apache/plc4x/plc4go/spi"
 	"github.com/apache/plc4x/plc4go/spi/transports/pcap"
-	"github.com/rs/zerolog/log"
+
 	"github.com/stretchr/testify/require"
 )
 
@@ -73,10 +73,10 @@ func TestBacnetDriverWithPcap(t *testing.T) {
 	if requestResult.GetErr() != nil {
 		panic(requestResult.GetErr())
 	}
-	log.Info().Msgf("got response %v", requestResult.GetResponse())
+	t.Logf("got response %v", requestResult.GetResponse())
 
 	for connection.IsConnected() {
-		log.Debug().Msg("Still sleeping")
+		t.Log("Still sleeping")
 		time.Sleep(time.Second)
 	}
 }
diff --git a/plc4go/tests/drivers/tests/manual_bacnet_driver_test.go b/plc4go/tests/drivers/tests/manual_bacnet_driver_test.go
index 504b19fcb6..0acadfc436 100644
--- a/plc4go/tests/drivers/tests/manual_bacnet_driver_test.go
+++ b/plc4go/tests/drivers/tests/manual_bacnet_driver_test.go
@@ -20,12 +20,13 @@
 package tests
 
 import (
+	"testing"
+
 	"github.com/apache/plc4x/plc4go/internal/bacnetip"
 	"github.com/apache/plc4x/plc4go/pkg/api"
 	"github.com/apache/plc4x/plc4go/pkg/api/transports"
 	"github.com/apache/plc4x/plc4go/spi/testutils"
 	_ "github.com/apache/plc4x/plc4go/tests/initializetest"
-	"testing"
 )
 
 func TestManualBacnetDriver(t *testing.T) {
diff --git a/plc4go/tests/drivers/tests/manual_bacnet_test.go b/plc4go/tests/drivers/tests/manual_bacnet_test.go
index c1d563187f..2b32d37f82 100644
--- a/plc4go/tests/drivers/tests/manual_bacnet_test.go
+++ b/plc4go/tests/drivers/tests/manual_bacnet_test.go
@@ -24,6 +24,7 @@ import (
 
 	"github.com/apache/plc4x/plc4go/protocols/bacnetip/readwrite/model"
 	_ "github.com/apache/plc4x/plc4go/tests/initializetest"
+
 	"github.com/stretchr/testify/require"
 )
 
diff --git a/plc4go/tests/drivers/tests/manual_cbus_driver_test.go b/plc4go/tests/drivers/tests/manual_cbus_driver_test.go
index 2231850595..205f8d4515 100644
--- a/plc4go/tests/drivers/tests/manual_cbus_driver_test.go
+++ b/plc4go/tests/drivers/tests/manual_cbus_driver_test.go
@@ -31,6 +31,7 @@ import (
 	"github.com/apache/plc4x/plc4go/spi/testutils"
 	"github.com/apache/plc4x/plc4go/spi/utils"
 	_ "github.com/apache/plc4x/plc4go/tests/initializetest"
+
 	"github.com/stretchr/testify/require"
 )
 
diff --git a/plc4go/tests/drivers/tests/manual_s7_driver_test.go b/plc4go/tests/drivers/tests/manual_s7_driver_test.go
index 835bba757b..8b599a4f85 100644
--- a/plc4go/tests/drivers/tests/manual_s7_driver_test.go
+++ b/plc4go/tests/drivers/tests/manual_s7_driver_test.go
@@ -20,12 +20,13 @@
 package tests
 
 import (
+	"testing"
+
 	"github.com/apache/plc4x/plc4go/internal/s7"
 	"github.com/apache/plc4x/plc4go/pkg/api"
 	"github.com/apache/plc4x/plc4go/pkg/api/transports"
 	"github.com/apache/plc4x/plc4go/spi/testutils"
 	_ "github.com/apache/plc4x/plc4go/tests/initializetest"
-	"testing"
 )
 
 func TestManualS7Driver(t *testing.T) {
diff --git a/plc4go/tests/drivers/tests/modbus_parser_serializer_test.go b/plc4go/tests/drivers/tests/modbus_parser_serializer_test.go
index 86ddb25adf..9ae44c137b 100644
--- a/plc4go/tests/drivers/tests/modbus_parser_serializer_test.go
+++ b/plc4go/tests/drivers/tests/modbus_parser_serializer_test.go
@@ -20,13 +20,15 @@
 package tests
 
 import (
+	"testing"
+
+	modbusIO "github.com/apache/plc4x/plc4go/protocols/modbus/readwrite"
 	"github.com/apache/plc4x/plc4go/spi/testutils"
 	_ "github.com/apache/plc4x/plc4go/tests/initializetest"
-	"testing"
 )
 
 func TestModbusParserSerializer(t *testing.T) {
-	//testutils.RunParserSerializerTestsuite(t, "assets/testing/protocols/modbus/ascii/ParserSerializerTestsuite.xml")
-	//testutils.RunParserSerializerTestsuite(t, "assets/testing/protocols/modbus/rtu/ParserSerializerTestsuite.xml")
-	testutils.RunParserSerializerTestsuite(t, "assets/testing/protocols/modbus/tcp/ParserSerializerTestsuite.xml")
+	//testutils.RunParserSerializerTestsuite(t, "assets/testing/protocols/modbus/ascii/ParserSerializerTestsuite.xml", modbusIO.ModbusParserHelper{})
+	//testutils.RunParserSerializerTestsuite(t, "assets/testing/protocols/modbus/rtu/ParserSerializerTestsuite.xml", modbusIO.ModbusParserHelper{})
+	testutils.RunParserSerializerTestsuite(t, "assets/testing/protocols/modbus/tcp/ParserSerializerTestsuite.xml", modbusIO.ModbusParserHelper{})
 }
diff --git a/plc4go/tests/drivers/tests/s7_parser_serializer_test.go b/plc4go/tests/drivers/tests/s7_parser_serializer_test.go
index 09caff7ad8..88ff71eb57 100644
--- a/plc4go/tests/drivers/tests/s7_parser_serializer_test.go
+++ b/plc4go/tests/drivers/tests/s7_parser_serializer_test.go
@@ -20,11 +20,13 @@
 package tests
 
 import (
+	"testing"
+
+	s7IO "github.com/apache/plc4x/plc4go/protocols/s7/readwrite"
 	"github.com/apache/plc4x/plc4go/spi/testutils"
 	_ "github.com/apache/plc4x/plc4go/tests/initializetest"
-	"testing"
 )
 
 func TestS7ParserSerializer(t *testing.T) {
-	testutils.RunParserSerializerTestsuite(t, "assets/testing/protocols/s7/ParserSerializerTestsuite.xml")
+	testutils.RunParserSerializerTestsuite(t, "assets/testing/protocols/s7/ParserSerializerTestsuite.xml", s7IO.S7ParserHelper{})
 }