You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@plc4x.apache.org by sr...@apache.org on 2024/08/29 11:11:07 UTC

(plc4x) 02/03: test(plc4go/bacnetip): simple test sequence

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 ca0f656b2dd880f9ab9622064b16af9c435f1c03
Author: Sebastian Rühl <sr...@apache.org>
AuthorDate: Thu Aug 29 11:59:21 2024 +0200

    test(plc4go/bacnetip): simple test sequence
---
 plc4go/internal/bacnetip/apdu_APCISequence.go      |  14 +-
 .../bacnetip/apdu_UnconfirmedRequestPDU.go         |   5 +-
 plc4go/internal/bacnetip/capability.go             |  39 ++-
 plc4go/internal/bacnetip/constructeddata.go        | 344 ++++++++++++++++++++-
 .../mock_SequenceContractRequirement_test.go       | 131 ++++++++
 .../bacnetip/mock_SequenceContract_test.go         |  98 ++++++
 plc4go/internal/bacnetip/mock_Tag_test.go          |  58 ++++
 plc4go/internal/bacnetip/primitivedata_Atomic.go   |   5 +-
 .../internal/bacnetip/primitivedata_BitString.go   |  13 +-
 plc4go/internal/bacnetip/primitivedata_Boolean.go  |  13 +-
 .../bacnetip/primitivedata_CharacterString.go      |  13 +-
 plc4go/internal/bacnetip/primitivedata_Date.go     |  18 +-
 plc4go/internal/bacnetip/primitivedata_Double.go   |  13 +-
 .../internal/bacnetip/primitivedata_Enumeration.go |  13 +-
 plc4go/internal/bacnetip/primitivedata_Integer.go  |  13 +-
 plc4go/internal/bacnetip/primitivedata_Null.go     |  13 +-
 .../bacnetip/primitivedata_ObjectIdentifier.go     |  13 +-
 .../internal/bacnetip/primitivedata_OctetString.go |  13 +-
 plc4go/internal/bacnetip/primitivedata_Real.go     |  13 +-
 plc4go/internal/bacnetip/primitivedata_Tag.go      |   3 +-
 plc4go/internal/bacnetip/primitivedata_Time.go     |  13 +-
 plc4go/internal/bacnetip/primitivedata_Unsigned.go |  13 +-
 .../internal/bacnetip/primitivedata_Unsigned16.go  |  13 +-
 .../internal/bacnetip/primitivedata_Unsigned8.go   |  13 +-
 .../tests/test_comm/test_capability_test.go        |  33 +-
 .../tests/test_constructed_data/helpers.go         |  97 ++++++
 .../mock_SequenceEqualityRequirements_test.go      | 101 ++++++
 .../test_constructed_data/test_sequence_test.go    |  72 +++++
 .../bacnetip/tests/test_network/helpers.go         |   2 +-
 .../bacnetip/tests/test_network/test_net_1_test.go |   5 +-
 .../bacnetip/tests/test_network/test_net_2_test.go |   5 +-
 .../bacnetip/tests/test_network/test_net_3_test.go | 224 +++++++++++++-
 .../tests/test_primitive_data/test_tag_test.go     |   5 +-
 33 files changed, 1362 insertions(+), 79 deletions(-)

diff --git a/plc4go/internal/bacnetip/apdu_APCISequence.go b/plc4go/internal/bacnetip/apdu_APCISequence.go
index 93ec459543..e9bb61812f 100644
--- a/plc4go/internal/bacnetip/apdu_APCISequence.go
+++ b/plc4go/internal/bacnetip/apdu_APCISequence.go
@@ -33,14 +33,22 @@ type APCISequence struct {
 	tagList *TagList
 }
 
-func NewAPCISequence() *APCISequence {
+func NewAPCISequence() (*APCISequence, error) {
 	a := &APCISequence{}
 	a._APCI = NewAPCI(nil, nil).(*_APCI) // TODO: what to pass up?
-	a.Sequence = NewSequence()
+	var err error
+	a.Sequence, err = NewSequence(NoKWArgs, WithSequenceContract(a))
+	if err != nil {
+		return nil, errors.Wrap(err, "error creating sequence")
+	}
 
 	// start with an empty tag list
 	a.tagList = NewTagList(nil)
-	return a
+	return a, nil
+}
+
+func (a *APCISequence) SetSequence(sequence *Sequence) {
+	a.Sequence = sequence
 }
 
 func (a *APCISequence) Encode(apdu Arg) error {
diff --git a/plc4go/internal/bacnetip/apdu_UnconfirmedRequestPDU.go b/plc4go/internal/bacnetip/apdu_UnconfirmedRequestPDU.go
index 6d85211afb..58ced92290 100644
--- a/plc4go/internal/bacnetip/apdu_UnconfirmedRequestPDU.go
+++ b/plc4go/internal/bacnetip/apdu_UnconfirmedRequestPDU.go
@@ -38,8 +38,11 @@ func NewUnconfirmedRequestPDU() (*UnconfirmedRequestPDU, error) {
 
 func NewUnconfirmedRequestSequence() (*UnconfirmedRequestSequence, error) {
 	u := &UnconfirmedRequestSequence{}
-	u.APCISequence = NewAPCISequence()
 	var err error
+	u.APCISequence, err = NewAPCISequence()
+	if err != nil {
+		return nil, errors.Wrap(err, "error creating _APCISequence")
+	}
 	u.UnconfirmedRequestPDU, err = NewUnconfirmedRequestPDU()
 	if err != nil {
 		return nil, errors.Wrap(err, "error creating UnconfirmedRequestPDU")
diff --git a/plc4go/internal/bacnetip/capability.go b/plc4go/internal/bacnetip/capability.go
index c01f655bd7..56c51b34cf 100644
--- a/plc4go/internal/bacnetip/capability.go
+++ b/plc4go/internal/bacnetip/capability.go
@@ -19,6 +19,8 @@
 
 package bacnetip
 
+import "github.com/rs/zerolog"
+
 // TODO: implement
 type Capability struct {
 }
@@ -27,20 +29,51 @@ func NewCapability() *Capability {
 	return &Capability{}
 }
 
+func (c *Capability) getFN(fn string) func(args Args, kwargs KWArgs) error {
+	panic("implement me")
+}
+
+func (c *Capability) String() string {
+	panic("implement me")
+}
+
 // TODO: implement
 type Collector struct {
+	capabilities []*Capability
+
+	log zerolog.Logger
 }
 
-func NewCollector() *Collector {
-	return &Collector{}
+func NewCollector(localLog zerolog.Logger) *Collector {
+	return &Collector{log: localLog}
 }
 
 func (c *Collector) searchCapability() {
 	panic("not implemented") // TODO: implement me
 }
 
+// CapabilityFunctions generator yields functions that match the requested capability sorted by z-index.
 func (c *Collector) CapabilityFunctions(fn string) []func(args Args, kwargs KWArgs) error {
-	panic("not implemented") // TODO: implement me
+	c.log.Trace().Msg("CapabilityFunctions")
+
+	// build a list of functions to call
+	var fns []func(args Args, kwargs KWArgs) error
+	for _, capability := range c.capabilities {
+		xfn := capability.getFN(fn)
+		c.log.Trace().Stringer("capability", capability).Bool("xfn", xfn != nil).Msg("cap")
+		if xfn != nil {
+			// TODO: sorting
+			fns = append(fns, xfn)
+		}
+	}
+
+	// sort them by z-index
+	// TODO: sorting
+
+	// now yield them in order
+	// TODO: what?
+
+	return fns
 }
 
 func (c *Collector) AddCapability(cls any) {
diff --git a/plc4go/internal/bacnetip/constructeddata.go b/plc4go/internal/bacnetip/constructeddata.go
index f74ec38df6..f6781b7ae3 100644
--- a/plc4go/internal/bacnetip/constructeddata.go
+++ b/plc4go/internal/bacnetip/constructeddata.go
@@ -19,26 +19,338 @@
 
 package bacnetip
 
-import "github.com/pkg/errors"
+import (
+	"reflect"
+
+	"github.com/pkg/errors"
+
+	readWriteModel "github.com/apache/plc4x/plc4go/protocols/bacnetip/readwrite/model"
+)
+
+var _sequenceOfClasses map[any]struct{}
+var _listOfClasses map[any]struct{}
+
+func init() {
+	_sequenceOfClasses = make(map[any]struct{})
+	_listOfClasses = make(map[any]struct{})
+}
+
+type Element interface {
+	GetName() string
+	GetKlass() func(Args, KWArgs) (interface{ Encode(Arg) error }, error)
+	GetContext() *int
+	IsOptional() bool
+	Encode(tagList Arg) error
+}
 
 // TODO: finish
-type Element struct {
+type _Element struct {
+	Name     string
+	Klass    func(Args, KWArgs) (interface{ Encode(Arg) error }, error)
+	Context  *int
+	Optional bool
+}
+
+func NewElement(name string, klass func(Args, KWArgs) (interface{ Encode(Arg) error }, error)) Element {
+	e := &_Element{
+		Name:  name,
+		Klass: klass,
+	}
+	return e
+}
+
+var _ Element = (*_Element)(nil)
+
+func (e *_Element) GetName() string {
+	return e.Name
+}
+
+func (e *_Element) GetKlass() func(Args, KWArgs) (interface{ Encode(Arg) error }, error) {
+	return e.Klass
+}
+
+func (e *_Element) GetContext() *int {
+	return e.Context
+}
+
+func (e *_Element) IsOptional() bool {
+	return e.Optional
+}
+
+func (e *_Element) Encode(tagList Arg) error {
+	//TODO implement me
+	panic("implement me")
+}
+
+// SequenceContract provides a set of functions which can be overwritten by a sub struct
+type SequenceContract interface {
+	GetSequenceElements() []Element
+}
+
+// SequenceContractRequirement is needed when one want to extend using SequenceContract
+type SequenceContractRequirement interface {
+	SequenceContract
+	// SetSequence callback is needed as we work in the constructor already with the finished object // TODO: maybe we need to return as init again as it might not be finished constructing....
+	SetSequence(sequence *Sequence)
 }
 
 // TODO: finish
 type Sequence struct {
+	_contract        SequenceContract
+	sequenceElements []Element
+	attr             map[string]any
 }
 
-func NewSequence() *Sequence {
-	panic("implement me")
+// NewSequence Create a sequence element, optionally providing attribute/property values.
+func NewSequence(kwargs KWArgs, opts ...func(*Sequence)) (*Sequence, error) {
+	s := &Sequence{
+		attr: make(map[string]any),
+	}
+	for _, opt := range opts {
+		opt(s)
+	}
+	if s._contract == nil {
+		s._contract = s
+	} else {
+		s._contract.(SequenceContractRequirement).SetSequence(s)
+	}
+
+	var myKWArgs = make(KWArgs)
+	var otherKWArgs = make(KWArgs)
+	for _, element := range s._contract.GetSequenceElements() {
+		if a, ok := kwargs[KnownKey(element.GetName())]; ok {
+			myKWArgs[KnownKey(element.GetName())] = a
+		}
+	}
+	for key, a := range kwargs {
+		if _, ok := myKWArgs[key]; !ok {
+			otherKWArgs[key] = a
+		}
+	}
+
+	if len(otherKWArgs) > 0 {
+		return nil, errors.Errorf("invalid arguments %v", otherKWArgs)
+	}
+
+	// set the attribute/property values for the ones provided
+	for _, element := range s._contract.GetSequenceElements() {
+		a, ok := myKWArgs[KnownKey(element.GetName())]
+		if ok {
+			s.attr[element.GetName()] = a
+		}
+	}
+	return s, nil
 }
 
-func (a *Sequence) Encode(apdu Arg) error {
-	panic("implement me")
+func WithSequenceContract(contract SequenceContractRequirement) func(*Sequence) {
+	return func(s *Sequence) {
+		s._contract = contract
+	}
 }
 
-func (a *Sequence) Decode(apdu Arg) error {
-	panic("implement me")
+func (a *Sequence) GetSequenceElements() []Element {
+	return a.sequenceElements
+}
+
+func (a *Sequence) Encode(arg Arg) error {
+	tagList, ok := arg.(*TagList)
+	if !ok {
+		return errors.New("arg is not a TagList")
+	}
+
+	for _, element := range a._contract.GetSequenceElements() {
+		value, ok := a.attr[element.GetName()]
+		if element.IsOptional() && !ok {
+			continue
+		}
+		if !element.IsOptional() && !ok {
+			return errors.Errorf("%s is a missing required element of %T", element.GetName(), a)
+		}
+		elementKlass, err := element.GetKlass()(NoArgs, NoKWArgs)
+		if err != nil {
+			return errors.New("can't get zero object")
+		}
+		_, elementInSequenceOfClasses := _sequenceOfClasses[elementKlass]
+		_, elementInListOfClasses := _listOfClasses[elementKlass]
+		isAtomic := false
+		switch elementKlass.(type) {
+		case IsAtomic, IsAnyAtomic:
+			isAtomic = true
+		}
+		isValue := reflect.TypeOf(value) == reflect.TypeOf(elementKlass)
+
+		if elementInSequenceOfClasses || elementInListOfClasses {
+			// might need to encode an opening tag
+			if element.GetContext() != nil {
+				openingTag, err := NewOpeningTag(*element.GetContext())
+				if err != nil {
+					return errors.Wrap(err, "error creating opening tag")
+				}
+				tagList.Append(openingTag)
+			}
+
+			helper, err := element.GetKlass()(NewArgs(value), NoKWArgs)
+			if err != nil {
+				return errors.Wrap(err, "error klass element")
+			}
+
+			// encode the value
+			if err := helper.Encode(tagList); err != nil {
+				return errors.Wrap(err, "error encoding tag list")
+			}
+
+			// might need to encode a closing tag
+			if element.GetContext() != nil {
+				closingTag, err := NewClosingTag(*element.GetContext())
+				if err != nil {
+					return errors.Wrap(err, "error creating closing tag")
+				}
+				tagList.Append(closingTag)
+			}
+		} else if isAtomic {
+			helper, err := element.GetKlass()(NewArgs(value), NoKWArgs)
+			if err != nil {
+				return errors.Wrap(err, "error klass element")
+			}
+
+			// build a tag and encode the data into it
+			tag, err := NewTag(nil)
+			if err != nil {
+				return errors.Wrap(err, "error creating tag")
+			}
+			// encode the value
+			if err := helper.Encode(tag); err != nil {
+				return errors.Wrap(err, "error encoding tag list")
+			}
+
+			// convert it to context encoding if necessary
+			if element.GetContext() != nil {
+				tag, err = tag.AppToContext(uint(*element.GetContext()))
+				if err != nil {
+					return errors.Wrap(err, "error converting tag to context")
+				}
+			}
+			tagList.Append(tag)
+		} else if isValue {
+			// might need to encode an opening tag
+			if element.GetContext() != nil {
+				openingTag, err := NewOpeningTag(*element.GetContext())
+				if err != nil {
+					return errors.Wrap(err, "error creating opening tag")
+				}
+				tagList.Append(openingTag)
+			}
+
+			// encode the tag
+			if err := value.(interface{ Encode(Arg) error }).Encode(tagList); err != nil { // TODO: ugly case, need a encode interface soon
+				return errors.Wrap(err, "error encoding tag list")
+			}
+
+			// might need to encode a closing tag
+			if element.GetContext() != nil {
+				closingTag, err := NewClosingTag(*element.GetContext())
+				if err != nil {
+					return errors.Wrap(err, "error creating closing tag")
+				}
+				tagList.Append(closingTag)
+			}
+		}
+	}
+	return nil
+}
+
+func (a *Sequence) Decode(arg Arg) error {
+	tagList, ok := arg.(*TagList)
+	if !ok {
+		return errors.New("arg is not a TagList")
+	}
+
+	for _, element := range a._contract.GetSequenceElements() {
+		tag := tagList.Peek()
+
+		elementKlass, err := element.GetKlass()(NoArgs, NoKWArgs)
+		if err != nil {
+			return errors.New("can't get zero object")
+		}
+		_, elementInSequenceOfClasses := _sequenceOfClasses[elementKlass]
+		_, elementInListOfClasses := _listOfClasses[elementKlass]
+		isAtomic := false
+		isAnyAtomic := false
+		switch elementKlass.(type) {
+		case IsAtomic:
+			isAtomic = true
+		case IsAnyAtomic:
+			isAnyAtomic = true
+		}
+		// no more elements
+		if tag == nil {
+			if element.IsOptional() {
+				// ommited optional element
+				a.attr[element.GetName()] = nil
+			} else if elementInSequenceOfClasses || elementInListOfClasses {
+				// empty list
+				//a.attr[element.GetName()] = nil // TODO: what to do???
+			} else {
+				return errors.Errorf("%s is a missing required element of %T", element.GetName(), a)
+			}
+		} else if tag.GetTagClass() == TagClosingTagClass {
+			if !element.IsOptional() {
+				return errors.Errorf("%s is a missing required element of %T", element.GetName(), a)
+			}
+
+			// ommited optional element
+			// a.attr[element.GetName()] = nil // TODO: don't set it for now as we use _,ok:=
+		} else if elementInSequenceOfClasses {
+			// check for context encoding
+			panic("finish me") // TODO: finish me
+		} else if isAnyAtomic {
+			// convert it to application encoding
+			panic("finish me") // TODO: finish me
+		} else if isAtomic {
+			// convert it to application encoding
+			if context := element.GetContext(); context != nil {
+				if tag.GetTagClass() != readWriteModel.TagClass_CONTEXT_SPECIFIC_TAGS { // TODO: store the application tag klass into Boolean for example so we can inspect that here
+					if !element.IsOptional() {
+						return errors.Errorf("%s expected context tag %d", element.GetName(), context)
+					} else {
+						// TODO: we don't do this
+						//a.attr[element.GetName()] = nil
+						continue
+					}
+				}
+				tag, err = tag.ContextToApp(uint(readWriteModel.BACnetDataType_BOOLEAN)) // TODO: store the application tag klass into Boolean for example so we can inspect that here
+				if err != nil {
+					return errors.Wrap(err, "error converting tag")
+				}
+			} else {
+				if tag.GetTagClass() != readWriteModel.TagClass_APPLICATION_TAGS { // TODO: store the application tag klass into Boolean for example so we can inspect that here
+					if !element.IsOptional() {
+						return errors.Errorf("%s expected context tag %d", element.GetName(), context)
+					} else {
+						// TODO: we don't do this
+						//a.attr[element.GetName()] = nil
+						continue
+					}
+				}
+			}
+
+			// consume the tag
+			tagList.Pop()
+
+			// a helper cooperates between the atomic value and the tag
+			helper, err := element.GetKlass()(NewArgs(tag), NoKWArgs)
+			if err != nil {
+				return errors.Wrap(err, "error creating helper")
+			}
+			a.attr[element.GetName()] = helper
+		} else if isAnyAtomic { // TODO: what is upstream doing here??? how???
+			// convert it to application encoding
+			panic("finish me") // TODO: finish me
+		} else {
+			panic("finish me") // TODO: finish me
+		}
+	}
+	return nil
 }
 
 // TODO: finish
@@ -158,11 +470,11 @@ type IsAnyAtomic interface {
 
 // TODO: finish me
 type AnyAtomic struct {
-	//*Atomic[int] // TODO: maybe we can't use that again
-
 	value any
 }
 
+var _ IsAnyAtomic = (*AnyAtomic)(nil)
+
 func NewAnyAtomic(args Args, opts ...func(*AnyAtomic)) *AnyAtomic {
 	a := &AnyAtomic{}
 	for _, opt := range opts {
@@ -171,17 +483,17 @@ func NewAnyAtomic(args Args, opts ...func(*AnyAtomic)) *AnyAtomic {
 	return a
 }
 
-func (a *AnyAtomic) GetValue() any {
-	return a.value
-}
-
 func (a *AnyAtomic) isAnyAtomic() bool {
 	return true
 }
 
-func (a *AnyAtomic) Encode(tag Tag) {}
+func (a *AnyAtomic) GetValue() any {
+	return a.value
+}
+
+func (a *AnyAtomic) Encode(arg Arg) {}
 
-func (a *AnyAtomic) Decode(tag Tag) error {
+func (a *AnyAtomic) Decode(arg Arg) error {
 	return nil
 }
 
diff --git a/plc4go/internal/bacnetip/mock_SequenceContractRequirement_test.go b/plc4go/internal/bacnetip/mock_SequenceContractRequirement_test.go
new file mode 100644
index 0000000000..9e9addd4c7
--- /dev/null
+++ b/plc4go/internal/bacnetip/mock_SequenceContractRequirement_test.go
@@ -0,0 +1,131 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+// Code generated by mockery v2.42.2. DO NOT EDIT.
+
+package bacnetip
+
+import mock "github.com/stretchr/testify/mock"
+
+// MockSequenceContractRequirement is an autogenerated mock type for the SequenceContractRequirement type
+type MockSequenceContractRequirement struct {
+	mock.Mock
+}
+
+type MockSequenceContractRequirement_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockSequenceContractRequirement) EXPECT() *MockSequenceContractRequirement_Expecter {
+	return &MockSequenceContractRequirement_Expecter{mock: &_m.Mock}
+}
+
+// GetSequenceElements provides a mock function with given fields:
+func (_m *MockSequenceContractRequirement) GetSequenceElements() []Element {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetSequenceElements")
+	}
+
+	var r0 []Element
+	if rf, ok := ret.Get(0).(func() []Element); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]Element)
+		}
+	}
+
+	return r0
+}
+
+// MockSequenceContractRequirement_GetSequenceElements_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSequenceElements'
+type MockSequenceContractRequirement_GetSequenceElements_Call struct {
+	*mock.Call
+}
+
+// GetSequenceElements is a helper method to define mock.On call
+func (_e *MockSequenceContractRequirement_Expecter) GetSequenceElements() *MockSequenceContractRequirement_GetSequenceElements_Call {
+	return &MockSequenceContractRequirement_GetSequenceElements_Call{Call: _e.mock.On("GetSequenceElements")}
+}
+
+func (_c *MockSequenceContractRequirement_GetSequenceElements_Call) Run(run func()) *MockSequenceContractRequirement_GetSequenceElements_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockSequenceContractRequirement_GetSequenceElements_Call) Return(_a0 []Element) *MockSequenceContractRequirement_GetSequenceElements_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockSequenceContractRequirement_GetSequenceElements_Call) RunAndReturn(run func() []Element) *MockSequenceContractRequirement_GetSequenceElements_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// SetSequence provides a mock function with given fields: sequence
+func (_m *MockSequenceContractRequirement) SetSequence(sequence *Sequence) {
+	_m.Called(sequence)
+}
+
+// MockSequenceContractRequirement_SetSequence_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSequence'
+type MockSequenceContractRequirement_SetSequence_Call struct {
+	*mock.Call
+}
+
+// SetSequence is a helper method to define mock.On call
+//   - sequence *Sequence
+func (_e *MockSequenceContractRequirement_Expecter) SetSequence(sequence interface{}) *MockSequenceContractRequirement_SetSequence_Call {
+	return &MockSequenceContractRequirement_SetSequence_Call{Call: _e.mock.On("SetSequence", sequence)}
+}
+
+func (_c *MockSequenceContractRequirement_SetSequence_Call) Run(run func(sequence *Sequence)) *MockSequenceContractRequirement_SetSequence_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(*Sequence))
+	})
+	return _c
+}
+
+func (_c *MockSequenceContractRequirement_SetSequence_Call) Return() *MockSequenceContractRequirement_SetSequence_Call {
+	_c.Call.Return()
+	return _c
+}
+
+func (_c *MockSequenceContractRequirement_SetSequence_Call) RunAndReturn(run func(*Sequence)) *MockSequenceContractRequirement_SetSequence_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewMockSequenceContractRequirement creates a new instance of MockSequenceContractRequirement. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockSequenceContractRequirement(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockSequenceContractRequirement {
+	mock := &MockSequenceContractRequirement{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
diff --git a/plc4go/internal/bacnetip/mock_SequenceContract_test.go b/plc4go/internal/bacnetip/mock_SequenceContract_test.go
new file mode 100644
index 0000000000..153627d2c3
--- /dev/null
+++ b/plc4go/internal/bacnetip/mock_SequenceContract_test.go
@@ -0,0 +1,98 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+// Code generated by mockery v2.42.2. DO NOT EDIT.
+
+package bacnetip
+
+import mock "github.com/stretchr/testify/mock"
+
+// MockSequenceContract is an autogenerated mock type for the SequenceContract type
+type MockSequenceContract struct {
+	mock.Mock
+}
+
+type MockSequenceContract_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockSequenceContract) EXPECT() *MockSequenceContract_Expecter {
+	return &MockSequenceContract_Expecter{mock: &_m.Mock}
+}
+
+// GetSequenceElements provides a mock function with given fields:
+func (_m *MockSequenceContract) GetSequenceElements() []Element {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetSequenceElements")
+	}
+
+	var r0 []Element
+	if rf, ok := ret.Get(0).(func() []Element); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]Element)
+		}
+	}
+
+	return r0
+}
+
+// MockSequenceContract_GetSequenceElements_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSequenceElements'
+type MockSequenceContract_GetSequenceElements_Call struct {
+	*mock.Call
+}
+
+// GetSequenceElements is a helper method to define mock.On call
+func (_e *MockSequenceContract_Expecter) GetSequenceElements() *MockSequenceContract_GetSequenceElements_Call {
+	return &MockSequenceContract_GetSequenceElements_Call{Call: _e.mock.On("GetSequenceElements")}
+}
+
+func (_c *MockSequenceContract_GetSequenceElements_Call) Run(run func()) *MockSequenceContract_GetSequenceElements_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockSequenceContract_GetSequenceElements_Call) Return(_a0 []Element) *MockSequenceContract_GetSequenceElements_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockSequenceContract_GetSequenceElements_Call) RunAndReturn(run func() []Element) *MockSequenceContract_GetSequenceElements_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewMockSequenceContract creates a new instance of MockSequenceContract. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockSequenceContract(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockSequenceContract {
+	mock := &MockSequenceContract{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
diff --git a/plc4go/internal/bacnetip/mock_Tag_test.go b/plc4go/internal/bacnetip/mock_Tag_test.go
index faa69010e4..e73daff540 100644
--- a/plc4go/internal/bacnetip/mock_Tag_test.go
+++ b/plc4go/internal/bacnetip/mock_Tag_test.go
@@ -154,6 +154,64 @@ func (_c *MockTag_AppToObject_Call) RunAndReturn(run func() (interface{}, error)
 	return _c
 }
 
+// ContextToApp provides a mock function with given fields: dataType
+func (_m *MockTag) ContextToApp(dataType uint) (Tag, error) {
+	ret := _m.Called(dataType)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ContextToApp")
+	}
+
+	var r0 Tag
+	var r1 error
+	if rf, ok := ret.Get(0).(func(uint) (Tag, error)); ok {
+		return rf(dataType)
+	}
+	if rf, ok := ret.Get(0).(func(uint) Tag); ok {
+		r0 = rf(dataType)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(Tag)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(uint) error); ok {
+		r1 = rf(dataType)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockTag_ContextToApp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContextToApp'
+type MockTag_ContextToApp_Call struct {
+	*mock.Call
+}
+
+// ContextToApp is a helper method to define mock.On call
+//   - dataType uint
+func (_e *MockTag_Expecter) ContextToApp(dataType interface{}) *MockTag_ContextToApp_Call {
+	return &MockTag_ContextToApp_Call{Call: _e.mock.On("ContextToApp", dataType)}
+}
+
+func (_c *MockTag_ContextToApp_Call) Run(run func(dataType uint)) *MockTag_ContextToApp_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(uint))
+	})
+	return _c
+}
+
+func (_c *MockTag_ContextToApp_Call) Return(_a0 Tag, _a1 error) *MockTag_ContextToApp_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockTag_ContextToApp_Call) RunAndReturn(run func(uint) (Tag, error)) *MockTag_ContextToApp_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // Decode provides a mock function with given fields: pdu
 func (_m *MockTag) Decode(pdu PDUData) error {
 	ret := _m.Called(pdu)
diff --git a/plc4go/internal/bacnetip/primitivedata_Atomic.go b/plc4go/internal/bacnetip/primitivedata_Atomic.go
index dc38c3f72f..0096f9d0a2 100644
--- a/plc4go/internal/bacnetip/primitivedata_Atomic.go
+++ b/plc4go/internal/bacnetip/primitivedata_Atomic.go
@@ -51,6 +51,9 @@ type Atomic[T ComparableAndOrdered] struct {
 	value T
 }
 
+var _ IsAtomic = (*Atomic[int])(nil)
+var _ AtomicContract[int] = (*Atomic[int])(nil)
+
 func NewAtomic[T ComparableAndOrdered](subStruct interface {
 	AtomicContract[T]
 	AtomicRequirements
@@ -61,7 +64,7 @@ func NewAtomic[T ComparableAndOrdered](subStruct interface {
 	}
 }
 
-func (a *Atomic[T]) isAtomic(bool) bool {
+func (a *Atomic[T]) isAtomic() bool {
 	return true
 }
 
diff --git a/plc4go/internal/bacnetip/primitivedata_BitString.go b/plc4go/internal/bacnetip/primitivedata_BitString.go
index 37e378b2aa..ca3c6f922c 100644
--- a/plc4go/internal/bacnetip/primitivedata_BitString.go
+++ b/plc4go/internal/bacnetip/primitivedata_BitString.go
@@ -92,7 +92,11 @@ func NewBitStringWithExtension(bitStringExtension BitStringExtension, args Args)
 	return b, nil
 }
 
-func (b *BitString) Decode(tag Tag) error {
+func (b *BitString) Decode(arg Arg) error {
+	tag, ok := arg.(Tag)
+	if !ok {
+		return errors.Errorf("%T is not a Tag", arg)
+	}
 	if tag.GetTagClass() != model.TagClass_APPLICATION_TAGS || tag.GetTagNumber() != uint(model.BACnetDataType_BIT_STRING) {
 		return errors.New("bit string application tag required")
 	}
@@ -123,7 +127,11 @@ func (b *BitString) Decode(tag Tag) error {
 	return nil
 }
 
-func (b *BitString) Encode(tag Tag) {
+func (b *BitString) Encode(arg Arg) error {
+	tag, ok := arg.(Tag)
+	if !ok {
+		return errors.Errorf("%T is not a Tag", arg)
+	}
 	used := len(b.value) % 8
 	unused := 8 - used
 	if unused == 8 {
@@ -150,6 +158,7 @@ func (b *BitString) Encode(tag Tag) {
 	}
 
 	tag.setAppData(uint(model.BACnetDataType_BIT_STRING), data)
+	return nil
 }
 
 func (b *BitString) Compare(other any) int {
diff --git a/plc4go/internal/bacnetip/primitivedata_Boolean.go b/plc4go/internal/bacnetip/primitivedata_Boolean.go
index 4e31714f33..3a31fbe138 100644
--- a/plc4go/internal/bacnetip/primitivedata_Boolean.go
+++ b/plc4go/internal/bacnetip/primitivedata_Boolean.go
@@ -66,11 +66,20 @@ func NewBoolean(arg Arg) (*Boolean, error) {
 	return b, nil
 }
 
-func (b *Boolean) Encode(tag Tag) {
+func (b *Boolean) Encode(arg Arg) error {
+	tag, ok := arg.(Tag)
+	if !ok {
+		return errors.Errorf("%T is not a Tag", arg)
+	} //TODO: move tag number into member variable
 	tag.set(NewArgs(model.TagClass_APPLICATION_TAGS, model.BACnetDataType_BOOLEAN, b.value, []byte{}))
+	return nil
 }
 
-func (b *Boolean) Decode(tag Tag) error {
+func (b *Boolean) Decode(arg Arg) error {
+	tag, ok := arg.(Tag)
+	if !ok {
+		return errors.Errorf("%T is not a Tag", arg)
+	}
 	if tag.GetTagClass() != model.TagClass_APPLICATION_TAGS || tag.GetTagNumber() != uint(model.BACnetDataType_BOOLEAN) {
 		return errors.New("boolean application tag required")
 	}
diff --git a/plc4go/internal/bacnetip/primitivedata_CharacterString.go b/plc4go/internal/bacnetip/primitivedata_CharacterString.go
index a7b3699560..411b08bb84 100644
--- a/plc4go/internal/bacnetip/primitivedata_CharacterString.go
+++ b/plc4go/internal/bacnetip/primitivedata_CharacterString.go
@@ -63,11 +63,20 @@ func NewCharacterString(arg Arg) (*CharacterString, error) {
 	return c, nil
 }
 
-func (c *CharacterString) Encode(tag Tag) {
+func (c *CharacterString) Encode(arg Arg) error {
+	tag, ok := arg.(Tag)
+	if !ok {
+		return errors.Errorf("%T is not a Tag", arg)
+	}
 	tag.setAppData(uint(model.BACnetDataType_CHARACTER_STRING), append([]byte{c.strEncoding}, c.strValue...))
+	return nil
 }
 
-func (c *CharacterString) Decode(tag Tag) error {
+func (c *CharacterString) Decode(arg Arg) error {
+	tag, ok := arg.(Tag)
+	if !ok {
+		return errors.Errorf("%T is not a Tag", arg)
+	}
 	if tag.GetTagClass() != model.TagClass_APPLICATION_TAGS || tag.GetTagNumber() != uint(model.BACnetDataType_CHARACTER_STRING) {
 		return errors.New("CharacterString application tag required")
 	}
diff --git a/plc4go/internal/bacnetip/primitivedata_Date.go b/plc4go/internal/bacnetip/primitivedata_Date.go
index d6a2ef7cc8..41708e0ef0 100644
--- a/plc4go/internal/bacnetip/primitivedata_Date.go
+++ b/plc4go/internal/bacnetip/primitivedata_Date.go
@@ -276,11 +276,21 @@ func (d *Date) now(arg float32) {
 	panic("implement me") // TODO
 }
 
-func (d *Date) Encode(tag Tag) {
+func (d *Date) Encode(arg Arg) error {
+	tag, ok := arg.(Tag)
+	if !ok {
+		return errors.Errorf("%T is not a Tag", arg)
+	}
 	tag.setAppData(uint(model.BACnetDataType_DATE), []byte{byte(d.value.Year), byte(d.value.Month), byte(d.value.Day), byte(d.value.DayOfWeek)})
+
+	return nil
 }
 
-func (d *Date) Decode(tag Tag) error {
+func (d *Date) Decode(arg Arg) error {
+	tag, ok := arg.(Tag)
+	if !ok {
+		return errors.Errorf("%T is not a Tag", arg)
+	}
 	if tag.GetTagClass() != model.TagClass_APPLICATION_TAGS || tag.GetTagNumber() != uint(model.BACnetDataType_DATE) {
 		return errors.New("Date application tag required")
 	}
@@ -288,8 +298,8 @@ func (d *Date) Decode(tag Tag) error {
 		return errors.New("invalid tag length")
 	}
 
-	arg := tag.GetTagData()
-	year, month, day, dayOfWeek := arg[0], arg[1], arg[2], arg[3]
+	td := tag.GetTagData()
+	year, month, day, dayOfWeek := td[0], td[1], td[2], td[3]
 	d.value.Year, d.value.Month, d.value.Day, d.value.DayOfWeek = int(year), int(month), int(day), int(dayOfWeek)
 	return nil
 }
diff --git a/plc4go/internal/bacnetip/primitivedata_Double.go b/plc4go/internal/bacnetip/primitivedata_Double.go
index 58dab36e76..e1edd4602d 100644
--- a/plc4go/internal/bacnetip/primitivedata_Double.go
+++ b/plc4go/internal/bacnetip/primitivedata_Double.go
@@ -63,13 +63,22 @@ func NewDouble(arg Arg) (*Double, error) {
 	return b, nil
 }
 
-func (d *Double) Encode(tag Tag) {
+func (d *Double) Encode(arg Arg) error {
+	tag, ok := arg.(Tag)
+	if !ok {
+		return errors.Errorf("%T is not a Tag", arg)
+	}
 	var _b = make([]byte, 8)
 	binary.BigEndian.PutUint64(_b, math.Float64bits(d.value))
 	tag.setAppData(uint(model.BACnetDataType_DOUBLE), _b)
+	return nil
 }
 
-func (d *Double) Decode(tag Tag) error {
+func (d *Double) Decode(arg Arg) error {
+	tag, ok := arg.(Tag)
+	if !ok {
+		return errors.Errorf("%T is not a Tag", arg)
+	}
 	if tag.GetTagClass() != model.TagClass_APPLICATION_TAGS || tag.GetTagNumber() != uint(model.BACnetDataType_DOUBLE) {
 		return errors.New("Double application tag required")
 	}
diff --git a/plc4go/internal/bacnetip/primitivedata_Enumeration.go b/plc4go/internal/bacnetip/primitivedata_Enumeration.go
index 8b9ec05c4f..f773899035 100644
--- a/plc4go/internal/bacnetip/primitivedata_Enumeration.go
+++ b/plc4go/internal/bacnetip/primitivedata_Enumeration.go
@@ -186,7 +186,11 @@ func (e *Enumerated) Compare(other any) int {
 	}
 }
 
-func (e *Enumerated) Decode(tag Tag) error {
+func (e *Enumerated) Decode(arg Arg) error {
+	tag, ok := arg.(Tag)
+	if !ok {
+		return errors.Errorf("%T is not a Tag", arg)
+	}
 	if tag.GetTagClass() != model.TagClass_APPLICATION_TAGS || tag.GetTagNumber() != uint(model.BACnetDataType_ENUMERATED) {
 		return errors.New("bit string application tag required")
 	}
@@ -210,7 +214,11 @@ func (e *Enumerated) Decode(tag Tag) error {
 	return nil
 }
 
-func (e *Enumerated) Encode(tag Tag) {
+func (e *Enumerated) Encode(arg Arg) error {
+	tag, ok := arg.(Tag)
+	if !ok {
+		return errors.Errorf("%T is not a Tag", arg)
+	}
 	value := e.value
 	if mappedValue, ok := e.EnumeratedContract.GetXlateTable()[e.valueString]; ok {
 		value = mappedValue.(uint64)
@@ -227,6 +235,7 @@ func (e *Enumerated) Encode(tag Tag) {
 
 	// encode the tag
 	tag.setAppData(uint(model.BACnetDataType_ENUMERATED), data)
+	return nil
 }
 
 func (e *Enumerated) IsValid(arg any) bool {
diff --git a/plc4go/internal/bacnetip/primitivedata_Integer.go b/plc4go/internal/bacnetip/primitivedata_Integer.go
index 656b2eaa0c..e83a428df6 100644
--- a/plc4go/internal/bacnetip/primitivedata_Integer.go
+++ b/plc4go/internal/bacnetip/primitivedata_Integer.go
@@ -64,7 +64,11 @@ func NewInteger(arg Arg) (*Integer, error) {
 	return i, nil
 }
 
-func (i *Integer) Encode(tag Tag) {
+func (i *Integer) Encode(arg Arg) error {
+	tag, ok := arg.(Tag)
+	if !ok {
+		return errors.Errorf("%T is not a Tag", arg)
+	}
 	data := make([]byte, 4)
 	binary.BigEndian.PutUint32(data, uint32(i.value))
 
@@ -93,9 +97,14 @@ func (i *Integer) Encode(tag Tag) {
 	}
 
 	tag.setAppData(uint(model.BACnetDataType_SIGNED_INTEGER), data)
+	return nil
 }
 
-func (i *Integer) Decode(tag Tag) error {
+func (i *Integer) Decode(arg Arg) error {
+	tag, ok := arg.(Tag)
+	if !ok {
+		return errors.Errorf("%T is not a Tag", arg)
+	}
 	if tag.GetTagClass() != model.TagClass_APPLICATION_TAGS || tag.GetTagNumber() != uint(model.BACnetDataType_SIGNED_INTEGER) {
 		return errors.New("Integer application tag required")
 	}
diff --git a/plc4go/internal/bacnetip/primitivedata_Null.go b/plc4go/internal/bacnetip/primitivedata_Null.go
index fa6d46a80d..6c8ffd1a93 100644
--- a/plc4go/internal/bacnetip/primitivedata_Null.go
+++ b/plc4go/internal/bacnetip/primitivedata_Null.go
@@ -54,11 +54,20 @@ func NewNull(arg Arg) (*Null, error) {
 	return b, nil
 }
 
-func (b *Null) Encode(tag Tag) {
+func (b *Null) Encode(arg Arg) error {
+	tag, ok := arg.(Tag)
+	if !ok {
+		return errors.Errorf("%T is not a Tag", arg)
+	}
 	tag.set(NewArgs(model.TagClass_APPLICATION_TAGS, model.BACnetDataType_NULL, b.value, []byte{}))
+	return nil
 }
 
-func (b *Null) Decode(tag Tag) error {
+func (b *Null) Decode(arg Arg) error {
+	tag, ok := arg.(Tag)
+	if !ok {
+		return errors.Errorf("%T is not a Tag", arg)
+	}
 	if tag.GetTagClass() != model.TagClass_APPLICATION_TAGS || tag.GetTagNumber() != uint(model.BACnetDataType_NULL) {
 		return errors.New("Null application tag required")
 	}
diff --git a/plc4go/internal/bacnetip/primitivedata_ObjectIdentifier.go b/plc4go/internal/bacnetip/primitivedata_ObjectIdentifier.go
index 685bafcce9..7ff8e72b32 100644
--- a/plc4go/internal/bacnetip/primitivedata_ObjectIdentifier.go
+++ b/plc4go/internal/bacnetip/primitivedata_ObjectIdentifier.go
@@ -158,13 +158,22 @@ func (o *ObjectIdentifier) getLong() int {
 	return (objType.(int) << 22) + objInstance
 }
 
-func (o *ObjectIdentifier) Encode(tag Tag) {
+func (o *ObjectIdentifier) Encode(arg Arg) error {
+	tag, ok := arg.(Tag)
+	if !ok {
+		return errors.Errorf("%T is not a Tag", arg)
+	}
 	data := make([]byte, 4)
 	binary.BigEndian.PutUint32(data, uint32(o.getLong()))
 	tag.setAppData(uint(model.BACnetDataType_BACNET_OBJECT_IDENTIFIER), data)
+	return nil
 }
 
-func (o *ObjectIdentifier) Decode(tag Tag) error {
+func (o *ObjectIdentifier) Decode(arg Arg) error {
+	tag, ok := arg.(Tag)
+	if !ok {
+		return errors.Errorf("%T is not a Tag", arg)
+	}
 	if tag.GetTagClass() != model.TagClass_APPLICATION_TAGS || tag.GetTagNumber() != uint(model.BACnetDataType_BACNET_OBJECT_IDENTIFIER) {
 		return errors.New("ObjectIdentifier application tag required")
 	}
diff --git a/plc4go/internal/bacnetip/primitivedata_OctetString.go b/plc4go/internal/bacnetip/primitivedata_OctetString.go
index 6d5283cfa0..954d64f0ed 100644
--- a/plc4go/internal/bacnetip/primitivedata_OctetString.go
+++ b/plc4go/internal/bacnetip/primitivedata_OctetString.go
@@ -60,11 +60,20 @@ func NewOctetString(arg Arg) (*OctetString, error) {
 	return o, nil
 }
 
-func (o *OctetString) Encode(tag Tag) {
+func (o *OctetString) Encode(arg Arg) error {
+	tag, ok := arg.(Tag)
+	if !ok {
+		return errors.Errorf("%T is not a Tag", arg)
+	}
 	tag.setAppData(uint(model.BACnetDataType_OCTET_STRING), o.value)
+	return nil
 }
 
-func (o *OctetString) Decode(tag Tag) error {
+func (o *OctetString) Decode(arg Arg) error {
+	tag, ok := arg.(Tag)
+	if !ok {
+		return errors.Errorf("%T is not a Tag", arg)
+	}
 	if tag.GetTagClass() != model.TagClass_APPLICATION_TAGS || tag.GetTagNumber() != uint(model.BACnetDataType_OCTET_STRING) {
 		return errors.New("OctetString application tag required")
 	}
diff --git a/plc4go/internal/bacnetip/primitivedata_Real.go b/plc4go/internal/bacnetip/primitivedata_Real.go
index 9f22f9bd83..e0003bb904 100644
--- a/plc4go/internal/bacnetip/primitivedata_Real.go
+++ b/plc4go/internal/bacnetip/primitivedata_Real.go
@@ -64,13 +64,22 @@ func NewReal(arg Arg) (*Real, error) {
 	return b, nil
 }
 
-func (d *Real) Encode(tag Tag) {
+func (d *Real) Encode(arg Arg) error {
+	tag, ok := arg.(Tag)
+	if !ok {
+		return errors.Errorf("%T is not a Tag", arg)
+	}
 	var _b = make([]byte, 4)
 	binary.BigEndian.PutUint32(_b, math.Float32bits(d.value))
 	tag.setAppData(uint(model.BACnetDataType_REAL), _b)
+	return nil
 }
 
-func (d *Real) Decode(tag Tag) error {
+func (d *Real) Decode(arg Arg) error {
+	tag, ok := arg.(Tag)
+	if !ok {
+		return errors.Errorf("%T is not a Tag", arg)
+	}
 	if tag.GetTagClass() != model.TagClass_APPLICATION_TAGS || tag.GetTagNumber() != uint(model.BACnetDataType_REAL) {
 		return errors.New("Real application tag required")
 	}
diff --git a/plc4go/internal/bacnetip/primitivedata_Tag.go b/plc4go/internal/bacnetip/primitivedata_Tag.go
index c7b103d33b..7302c772a8 100644
--- a/plc4go/internal/bacnetip/primitivedata_Tag.go
+++ b/plc4go/internal/bacnetip/primitivedata_Tag.go
@@ -75,6 +75,7 @@ type Tag interface {
 	Decode(pdu PDUData) error
 	AppToObject() (any, error)
 	AppToContext(context uint) (*ContextTag, error)
+	ContextToApp(dataType uint) (Tag, error) // TODO: can't be ApplicationTag because boolean gets encoded as Tag???
 	setAppData(tagNumber uint, tdata []byte)
 	set(args Args)
 }
@@ -240,7 +241,7 @@ func (t *tag) AppToContext(context uint) (*ContextTag, error) {
 	return NewContextTag(NewArgs(context, t.tagData))
 }
 
-func (t *tag) ContextToApp(dataType uint) (any, error) {
+func (t *tag) ContextToApp(dataType uint) (Tag, error) {
 	if t.tagClass != model.TagClass_CONTEXT_SPECIFIC_TAGS {
 		return nil, errors.New("context tag required")
 	}
diff --git a/plc4go/internal/bacnetip/primitivedata_Time.go b/plc4go/internal/bacnetip/primitivedata_Time.go
index 57063b3a7d..e2c63e876b 100644
--- a/plc4go/internal/bacnetip/primitivedata_Time.go
+++ b/plc4go/internal/bacnetip/primitivedata_Time.go
@@ -128,11 +128,20 @@ func (t *Time) now(arg float32) {
 	panic("implement me") // TODO
 }
 
-func (t *Time) Encode(tag Tag) {
+func (t *Time) Encode(arg Arg) error {
+	tag, ok := arg.(Tag)
+	if !ok {
+		return errors.Errorf("%T is not a Tag", arg)
+	}
 	tag.setAppData(uint(model.BACnetDataType_TIME), []byte{byte(t.value.Hour), byte(t.value.Minute), byte(t.value.Second), byte(t.value.Hundredth)})
+	return nil
 }
 
-func (t *Time) Decode(tag Tag) error {
+func (t *Time) Decode(arg Arg) error {
+	tag, ok := arg.(Tag)
+	if !ok {
+		return errors.Errorf("%T is not a Tag", arg)
+	}
 	if tag.GetTagClass() != model.TagClass_APPLICATION_TAGS || tag.GetTagNumber() != uint(model.BACnetDataType_TIME) {
 		return errors.New("Time application tag required")
 	}
diff --git a/plc4go/internal/bacnetip/primitivedata_Unsigned.go b/plc4go/internal/bacnetip/primitivedata_Unsigned.go
index 7bdb262ccf..97e04000fb 100644
--- a/plc4go/internal/bacnetip/primitivedata_Unsigned.go
+++ b/plc4go/internal/bacnetip/primitivedata_Unsigned.go
@@ -75,7 +75,11 @@ func NewUnsigned(arg Arg) (*Unsigned, error) {
 	return i, nil
 }
 
-func (i *Unsigned) Encode(tag Tag) {
+func (i *Unsigned) Encode(arg Arg) error {
+	tag, ok := arg.(Tag)
+	if !ok {
+		return errors.Errorf("%T is not a Tag", arg)
+	}
 	data := make([]byte, 4)
 	binary.BigEndian.PutUint32(data, i.value)
 
@@ -85,9 +89,14 @@ func (i *Unsigned) Encode(tag Tag) {
 	}
 
 	tag.setAppData(uint(model.BACnetDataType_UNSIGNED_INTEGER), data)
+	return nil
 }
 
-func (i *Unsigned) Decode(tag Tag) error {
+func (i *Unsigned) Decode(arg Arg) error {
+	tag, ok := arg.(Tag)
+	if !ok {
+		return errors.Errorf("%T is not a Tag", arg)
+	}
 	if tag.GetTagClass() != model.TagClass_APPLICATION_TAGS || tag.GetTagNumber() != uint(model.BACnetDataType_UNSIGNED_INTEGER) {
 		return errors.New("Unsigned application tag required")
 	}
diff --git a/plc4go/internal/bacnetip/primitivedata_Unsigned16.go b/plc4go/internal/bacnetip/primitivedata_Unsigned16.go
index 07078560fe..b14a1ac941 100644
--- a/plc4go/internal/bacnetip/primitivedata_Unsigned16.go
+++ b/plc4go/internal/bacnetip/primitivedata_Unsigned16.go
@@ -70,7 +70,11 @@ func NewUnsigned16(arg Arg) (*Unsigned16, error) {
 	return i, nil
 }
 
-func (i *Unsigned16) Encode(tag Tag) {
+func (i *Unsigned16) Encode(arg Arg) error {
+	tag, ok := arg.(Tag)
+	if !ok {
+		return errors.Errorf("%T is not a Tag", arg)
+	}
 	data := make([]byte, 4)
 	binary.BigEndian.PutUint32(data, uint32(i.value))
 
@@ -80,9 +84,14 @@ func (i *Unsigned16) Encode(tag Tag) {
 	}
 
 	tag.setAppData(uint(model.BACnetDataType_UNSIGNED_INTEGER), data)
+	return nil
 }
 
-func (i *Unsigned16) Decode(tag Tag) error {
+func (i *Unsigned16) Decode(arg Arg) error {
+	tag, ok := arg.(Tag)
+	if !ok {
+		return errors.Errorf("%T is not a Tag", arg)
+	}
 	if tag.GetTagClass() != model.TagClass_APPLICATION_TAGS || tag.GetTagNumber() != uint(model.BACnetDataType_UNSIGNED_INTEGER) {
 		return errors.New("Unsigned16 application tag required")
 	}
diff --git a/plc4go/internal/bacnetip/primitivedata_Unsigned8.go b/plc4go/internal/bacnetip/primitivedata_Unsigned8.go
index 9c06b0c5d5..8c55905915 100644
--- a/plc4go/internal/bacnetip/primitivedata_Unsigned8.go
+++ b/plc4go/internal/bacnetip/primitivedata_Unsigned8.go
@@ -70,7 +70,11 @@ func NewUnsigned8(arg Arg) (*Unsigned8, error) {
 	return i, nil
 }
 
-func (i *Unsigned8) Encode(tag Tag) {
+func (i *Unsigned8) Encode(arg Arg) error {
+	tag, ok := arg.(Tag)
+	if !ok {
+		return errors.Errorf("%T is not a Tag", arg)
+	}
 	data := make([]byte, 4)
 	binary.BigEndian.PutUint32(data, uint32(i.value))
 
@@ -80,9 +84,14 @@ func (i *Unsigned8) Encode(tag Tag) {
 	}
 
 	tag.setAppData(uint(model.BACnetDataType_UNSIGNED_INTEGER), data)
+	return nil
 }
 
-func (i *Unsigned8) Decode(tag Tag) error {
+func (i *Unsigned8) Decode(arg Arg) error {
+	tag, ok := arg.(Tag)
+	if !ok {
+		return errors.Errorf("%T is not a Tag", arg)
+	}
 	if tag.GetTagClass() != model.TagClass_APPLICATION_TAGS || tag.GetTagNumber() != uint(model.BACnetDataType_UNSIGNED_INTEGER) {
 		return errors.New("Unsigned8 application tag required")
 	}
diff --git a/plc4go/internal/bacnetip/tests/test_comm/test_capability_test.go b/plc4go/internal/bacnetip/tests/test_comm/test_capability_test.go
index b7930d0900..6f35f5a02a 100644
--- a/plc4go/internal/bacnetip/tests/test_comm/test_capability_test.go
+++ b/plc4go/internal/bacnetip/tests/test_comm/test_capability_test.go
@@ -22,9 +22,11 @@ package test_comm
 import (
 	"testing"
 
+	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/assert"
 
 	"github.com/apache/plc4x/plc4go/internal/bacnetip"
+	"github.com/apache/plc4x/plc4go/spi/testutils"
 )
 
 // TODO: big WIP
@@ -33,9 +35,9 @@ type BaseCollector struct {
 	*bacnetip.Collector
 }
 
-func NewBaseCollector() *BaseCollector {
+func NewBaseCollector(localLog zerolog.Logger) *BaseCollector {
 	b := &BaseCollector{}
-	b.Collector = bacnetip.NewCollector()
+	b.Collector = bacnetip.NewCollector(localLog)
 	return b
 }
 
@@ -85,9 +87,9 @@ type Example1 struct {
 	*BaseCollector
 }
 
-func NewExample1() *Example1 {
+func NewExample1(localLog zerolog.Logger) *Example1 {
 	b := &Example1{}
-	b.BaseCollector = NewBaseCollector()
+	b.BaseCollector = NewBaseCollector(localLog)
 	return b
 }
 
@@ -100,9 +102,9 @@ type Example2 struct {
 	*PlusOne
 }
 
-func NewExample2() *Example2 {
+func NewExample2(localLog zerolog.Logger) *Example2 {
 	b := &Example2{}
-	b.BaseCollector = NewBaseCollector()
+	b.BaseCollector = NewBaseCollector(localLog)
 	b.PlusOne = NewPlusOne()
 	return b
 }
@@ -121,9 +123,9 @@ func (e *Example3) transform(value any) any {
 	return e.BaseCollector.transform(value)
 }
 
-func NewExample3() *Example3 {
+func NewExample3(localLog zerolog.Logger) *Example3 {
 	b := &Example3{}
-	b.BaseCollector = NewBaseCollector()
+	b.BaseCollector = NewBaseCollector(localLog)
 	b.TimesTen = NewTimesTen()
 	b.PlusOne = NewPlusOne()
 	return b
@@ -138,18 +140,23 @@ type Example4 struct {
 func TestExamples(t *testing.T) {
 	t.Skip("big WIP...") // TODO: big WIP
 	t.Run("test_example_1", func(t *testing.T) {
-		assert.Equal(t, 1, NewExample1().transform(1))
+		testingLogger := testutils.ProduceTestingLogger(t)
+		assert.Equal(t, 1, NewExample1(testingLogger).transform(1))
 	})
 	t.Run("test_example_2", func(t *testing.T) {
-		assert.Equal(t, 3, NewExample2().transform(2))
+		testingLogger := testutils.ProduceTestingLogger(t)
+		assert.Equal(t, 3, NewExample2(testingLogger).transform(2))
 	})
 	t.Run("test_example_3", func(t *testing.T) {
-		assert.Equal(t, 31, NewExample3().transform(3))
+		testingLogger := testutils.ProduceTestingLogger(t)
+		assert.Equal(t, 31, NewExample3(testingLogger).transform(3))
 	})
 	t.Run("test_example_4", func(t *testing.T) {
-		assert.Equal(t, []int{4, 4, 4, 4, 4, 4, 4, 4, 4, 4}, NewExample3().transform(4))
+		testingLogger := testutils.ProduceTestingLogger(t)
+		assert.Equal(t, []int{4, 4, 4, 4, 4, 4, 4, 4, 4, 4}, NewExample3(testingLogger).transform(4))
 	})
 	t.Run("test_example_5", func(t *testing.T) {
-		assert.Equal(t, 6, NewExample3().transform(5))
+		testingLogger := testutils.ProduceTestingLogger(t)
+		assert.Equal(t, 6, NewExample3(testingLogger).transform(5))
 	})
 }
diff --git a/plc4go/internal/bacnetip/tests/test_constructed_data/helpers.go b/plc4go/internal/bacnetip/tests/test_constructed_data/helpers.go
index 425cf3be58..9978caa5ff 100644
--- a/plc4go/internal/bacnetip/tests/test_constructed_data/helpers.go
+++ b/plc4go/internal/bacnetip/tests/test_constructed_data/helpers.go
@@ -18,3 +18,100 @@
  */
 
 package test_constructed_data
+
+import (
+	"github.com/pkg/errors"
+
+	. "github.com/apache/plc4x/plc4go/internal/bacnetip"
+)
+
+type SequenceEqualityRequirements interface {
+	GetSequenceElements() []Element
+}
+
+type SequenceEquality struct {
+	_requirements SequenceEqualityRequirements
+}
+
+func NewSequenceEquality(requirements SequenceEqualityRequirements) *SequenceEquality {
+	if requirements == nil {
+		panic("requirements cannot be nil")
+	}
+	return &SequenceEquality{_requirements: requirements}
+}
+
+func (s *SequenceEquality) Equals(other any) bool {
+	for _, element := range s._requirements.GetSequenceElements() {
+		if !element.IsOptional() && true {
+			panic("what??")
+		}
+	}
+	return true
+}
+
+type EmptySequence struct {
+	*Sequence
+	*SequenceEquality
+}
+
+func NewEmptySequence(kwargs KWArgs) (*EmptySequence, error) {
+	e := &EmptySequence{}
+	var err error
+	e.Sequence, err = NewSequence(kwargs, WithSequenceContract(e))
+	if err != nil {
+		return nil, errors.Wrap(err, "could not create sequence")
+	}
+	e.SequenceEquality = NewSequenceEquality(e)
+	return e, nil
+}
+
+func (e *EmptySequence) SetSequence(sequence *Sequence) {
+	e.Sequence = sequence
+}
+
+type SimpleSequence struct {
+	*Sequence
+	*SequenceEquality
+
+	sequenceElements []Element
+}
+
+func NewSimpleSequence(kwargs KWArgs) (*SimpleSequence, error) {
+	s := &SimpleSequence{
+		sequenceElements: []Element{
+			NewElement("hydrogen", func(args Args, _ KWArgs) (interface{ Encode(Arg) error }, error) {
+				var arg any
+				if len(args) == 1 {
+					arg = args[0]
+				}
+				boolean, err := NewBoolean(arg)
+				return boolean, err
+			}),
+		},
+	}
+	var err error
+	s.Sequence, err = NewSequence(kwargs, WithSequenceContract(s))
+	if err != nil {
+		return nil, errors.Wrap(err, "could not create sequence")
+	}
+	s.SequenceEquality = NewSequenceEquality(s)
+	return s, nil
+}
+
+func (e *SimpleSequence) SetSequence(sequence *Sequence) {
+	e.Sequence = sequence
+}
+
+func (e *SimpleSequence) GetSequenceElements() []Element {
+	return e.sequenceElements
+}
+
+type CompoundSequence1 struct {
+	*Sequence
+	*SequenceEquality
+}
+
+type CompoundSequence2 struct {
+	*Sequence
+	*SequenceEquality
+}
diff --git a/plc4go/internal/bacnetip/tests/test_constructed_data/mock_SequenceEqualityRequirements_test.go b/plc4go/internal/bacnetip/tests/test_constructed_data/mock_SequenceEqualityRequirements_test.go
new file mode 100644
index 0000000000..1d9a949b65
--- /dev/null
+++ b/plc4go/internal/bacnetip/tests/test_constructed_data/mock_SequenceEqualityRequirements_test.go
@@ -0,0 +1,101 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+// Code generated by mockery v2.42.2. DO NOT EDIT.
+
+package test_constructed_data
+
+import (
+	bacnetip "github.com/apache/plc4x/plc4go/internal/bacnetip"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// MockSequenceEqualityRequirements is an autogenerated mock type for the SequenceEqualityRequirements type
+type MockSequenceEqualityRequirements struct {
+	mock.Mock
+}
+
+type MockSequenceEqualityRequirements_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockSequenceEqualityRequirements) EXPECT() *MockSequenceEqualityRequirements_Expecter {
+	return &MockSequenceEqualityRequirements_Expecter{mock: &_m.Mock}
+}
+
+// GetSequenceElements provides a mock function with given fields:
+func (_m *MockSequenceEqualityRequirements) GetSequenceElements() []bacnetip.Element {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetSequenceElements")
+	}
+
+	var r0 []bacnetip.Element
+	if rf, ok := ret.Get(0).(func() []bacnetip.Element); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]bacnetip.Element)
+		}
+	}
+
+	return r0
+}
+
+// MockSequenceEqualityRequirements_GetSequenceElements_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSequenceElements'
+type MockSequenceEqualityRequirements_GetSequenceElements_Call struct {
+	*mock.Call
+}
+
+// GetSequenceElements is a helper method to define mock.On call
+func (_e *MockSequenceEqualityRequirements_Expecter) GetSequenceElements() *MockSequenceEqualityRequirements_GetSequenceElements_Call {
+	return &MockSequenceEqualityRequirements_GetSequenceElements_Call{Call: _e.mock.On("GetSequenceElements")}
+}
+
+func (_c *MockSequenceEqualityRequirements_GetSequenceElements_Call) Run(run func()) *MockSequenceEqualityRequirements_GetSequenceElements_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockSequenceEqualityRequirements_GetSequenceElements_Call) Return(_a0 []bacnetip.Element) *MockSequenceEqualityRequirements_GetSequenceElements_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockSequenceEqualityRequirements_GetSequenceElements_Call) RunAndReturn(run func() []bacnetip.Element) *MockSequenceEqualityRequirements_GetSequenceElements_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewMockSequenceEqualityRequirements creates a new instance of MockSequenceEqualityRequirements. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockSequenceEqualityRequirements(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockSequenceEqualityRequirements {
+	mock := &MockSequenceEqualityRequirements{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
diff --git a/plc4go/internal/bacnetip/tests/test_constructed_data/test_sequence_test.go b/plc4go/internal/bacnetip/tests/test_constructed_data/test_sequence_test.go
index 425cf3be58..0b448601fb 100644
--- a/plc4go/internal/bacnetip/tests/test_constructed_data/test_sequence_test.go
+++ b/plc4go/internal/bacnetip/tests/test_constructed_data/test_sequence_test.go
@@ -18,3 +18,75 @@
  */
 
 package test_constructed_data
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	. "github.com/apache/plc4x/plc4go/internal/bacnetip"
+)
+
+func TestEmptySequence(t *testing.T) {
+	t.Run("test_empty_sequence", func(t *testing.T) {
+		seq, err := NewEmptySequence(NoKWArgs)
+		require.NoError(t, err)
+		t.Logf("%#v", seq)
+
+		// encode it in a tag list
+		tagList := NewTagList(nil)
+		err = seq.Encode(tagList)
+		require.NoError(t, err)
+		t.Logf("%v", tagList)
+
+		// create another sequence and decode the tag list
+		seq, err = NewEmptySequence(NoKWArgs)
+		require.NoError(t, err)
+		err = seq.Decode(tagList)
+		require.NoError(t, err)
+		t.Logf("%#v", seq)
+	})
+	t.Run("test_no_elements", func(t *testing.T) {
+		// create another sequence and decode the tag list
+		_, err := NewEmptySequence(NewKWArgs(KnownKey("some_element"), nil))
+		require.Error(t, err)
+	})
+}
+
+func TestSimpleSequence(t *testing.T) {
+	t.Run("test_missing_element", func(t *testing.T) {
+		// create a sequence with a missing required element
+		seq, err := NewSimpleSequence(NoKWArgs)
+		require.NoError(t, err)
+
+		// encode it in a tag list
+		tagList := NewTagList(nil)
+		err = seq.Encode(tagList)
+		require.Error(t, err)
+	})
+	t.Run("test_wrong_type", func(t *testing.T) {
+		// create a sequence with wrong element value type
+		seq, err := NewSimpleSequence(NewKWArgs(KnownKey("hydrogen"), 12))
+		require.NoError(t, err)
+
+		// encode it in a tag list
+		tagList := NewTagList(nil)
+		err = seq.Encode(tagList)
+		require.Error(t, err)
+	})
+	t.Run("test_codec", func(t *testing.T) {
+		// create a sequence
+		seq, err := NewSimpleSequence(NewKWArgs(KnownKey("hydrogen"), false))
+		require.NoError(t, err)
+
+		// encode it in a tag list
+		tagList := NewTagList(nil)
+		err = seq.Encode(tagList)
+
+		// create another sequence and decode the taglist
+		seq, err = NewSimpleSequence(NoKWArgs)
+		require.NoError(t, err)
+		err = seq.Decode(tagList)
+		require.NoError(t, err)
+	})
+}
diff --git a/plc4go/internal/bacnetip/tests/test_network/helpers.go b/plc4go/internal/bacnetip/tests/test_network/helpers.go
index f871931984..52ac9fd0a9 100644
--- a/plc4go/internal/bacnetip/tests/test_network/helpers.go
+++ b/plc4go/internal/bacnetip/tests/test_network/helpers.go
@@ -415,7 +415,7 @@ type ApplicationNode struct {
 	log zerolog.Logger
 }
 
-func NewApplicationNode(localLog zerolog.Logger, address string, vlan *bacnetip.IPNetwork) (*ApplicationNode, error) {
+func NewApplicationNode(localLog zerolog.Logger, address string, vlan *bacnetip.Network) (*ApplicationNode, error) {
 	a := &ApplicationNode{
 		log: localLog,
 	}
diff --git a/plc4go/internal/bacnetip/tests/test_network/test_net_1_test.go b/plc4go/internal/bacnetip/tests/test_network/test_net_1_test.go
index cd369f12c6..f21efb5f53 100644
--- a/plc4go/internal/bacnetip/tests/test_network/test_net_1_test.go
+++ b/plc4go/internal/bacnetip/tests/test_network/test_net_1_test.go
@@ -134,11 +134,10 @@ func (t *TNetwork1) Run(timeLimit time.Duration) {
 }
 
 func TestNet1(t *testing.T) {
-	t.Run("TestSimple1", func(t *testing.T) {
-		tests.ExclusiveGlobalTimeMachine(t)
-
+	t.Run("TestSimple", func(t *testing.T) {
 		t.Run("testIdle", func(t *testing.T) {
 			// create a network
+			tests.ExclusiveGlobalTimeMachine(t)
 			tnet := NewTNetwork1(t)
 
 			// all start states are successful
diff --git a/plc4go/internal/bacnetip/tests/test_network/test_net_2_test.go b/plc4go/internal/bacnetip/tests/test_network/test_net_2_test.go
index 40c4bc2359..85164fc4a2 100644
--- a/plc4go/internal/bacnetip/tests/test_network/test_net_2_test.go
+++ b/plc4go/internal/bacnetip/tests/test_network/test_net_2_test.go
@@ -143,11 +143,10 @@ func (t *TNetwork2) Run(timeLimit time.Duration) {
 }
 
 func TestNet2(t *testing.T) {
-	t.Run("TestSimple1", func(t *testing.T) {
-		tests.ExclusiveGlobalTimeMachine(t)
-
+	t.Run("TestSimple", func(t *testing.T) {
 		t.Run("testIdle", func(t *testing.T) {
 			// create a network
+			tests.ExclusiveGlobalTimeMachine(t)
 			tnet := NewTNetwork2(t)
 
 			// all start states are successful
diff --git a/plc4go/internal/bacnetip/tests/test_network/test_net_3_test.go b/plc4go/internal/bacnetip/tests/test_network/test_net_3_test.go
index d4a0497522..517c499c63 100644
--- a/plc4go/internal/bacnetip/tests/test_network/test_net_3_test.go
+++ b/plc4go/internal/bacnetip/tests/test_network/test_net_3_test.go
@@ -19,4 +19,226 @@
 
 package test_network
 
-// TODO: implement me
+import (
+	"testing"
+	"time"
+
+	"github.com/rs/zerolog"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	. "github.com/apache/plc4x/plc4go/internal/bacnetip"
+	"github.com/apache/plc4x/plc4go/internal/bacnetip/tests"
+	"github.com/apache/plc4x/plc4go/spi/testutils"
+)
+
+type TNetwork3 struct {
+	*tests.StateMachineGroup
+
+	iut      *RouterNode
+	vlan1    *Network
+	td       *NetworkLayerStateMachine
+	sniffer1 *SnifferStateMachine
+	vlan2    *Network
+	app2     *ApplicationNode
+	sniffer2 *SnifferStateMachine
+
+	t *testing.T
+
+	log zerolog.Logger
+}
+
+func NewTNetwork3(t *testing.T) *TNetwork3 {
+	localLog := testutils.ProduceTestingLogger(t)
+	tn := &TNetwork3{
+		t:   t,
+		log: localLog,
+	}
+	tn.StateMachineGroup = tests.NewStateMachineGroup(localLog)
+
+	// reset the time machine
+	tests.ResetTimeMachine(tests.StartTime)
+	localLog.Trace().Msg("time machine reset")
+
+	var err error
+	// implementation under test
+	tn.iut, err = NewRouterNode(tn.log)
+	require.NoError(t, err)
+
+	// make a little LAN
+	tn.vlan1 = NewNetwork(localLog, WithNetworkName("vlan1"), WithNetworkBroadcastAddress(NewLocalBroadcast(nil)))
+
+	// Test devices
+	tn.td, err = NewNetworkLayerStateMachine(localLog, "1", tn.vlan1)
+	require.NoError(t, err)
+	tn.Append(tn.td)
+
+	// sniffer node
+	tn.sniffer1, err = NewSnifferStateMachine(localLog, "2", tn.vlan1)
+	require.NoError(t, err)
+	tn.Append(tn.sniffer1)
+
+	// add the network
+	err = tn.iut.AddNetwork("3", tn.vlan1, 1)
+	require.NoError(t, err)
+
+	//  make another little LAN
+	tn.vlan2 = NewNetwork(tn.log, WithNetworkName("vlan2"), WithNetworkBroadcastAddress(NewLocalBroadcast(nil)))
+
+	// application node, not a state machine
+	tn.app2, err = NewApplicationNode(tn.log, "4", tn.vlan2)
+	require.NoError(t, err)
+
+	//  sniffer node
+	tn.sniffer2, err = NewSnifferStateMachine(localLog, "5", tn.vlan2)
+	require.NoError(t, err)
+	tn.Append(tn.sniffer2)
+
+	//  add the network
+	err = tn.iut.AddNetwork("6", tn.vlan2, 2)
+	require.NoError(t, err)
+
+	return tn
+}
+
+func (t *TNetwork3) Run(timeLimit time.Duration) {
+	if timeLimit == 0 {
+		timeLimit = 60 * time.Second
+	}
+	t.log.Debug().Dur("time_limit", timeLimit).Msg("run")
+
+	// run the group
+	err := t.StateMachineGroup.Run()
+	require.NoError(t.t, err)
+
+	// run it some time
+	tests.RunTimeMachine(t.log, timeLimit, time.Time{})
+	t.log.Trace().Msg("time machine finished")
+	for _, machine := range t.StateMachineGroup.GetStateMachines() {
+		t.log.Debug().Stringer("machine", machine).Strs("transactionLog", machine.GetTransactionLog()).Msg("Machine:")
+	}
+
+	// check for success
+	success, failed := t.CheckForSuccess()
+	assert.True(t.t, success)
+	assert.False(t.t, failed)
+}
+
+func TestNet3(t *testing.T) {
+	t.Skip("needs capabilities and constructed data to work") // TODO: finish me
+	t.Run("TestSimple", func(t *testing.T) {
+		t.Run("testIdle", func(t *testing.T) {
+			// create a network
+			tests.ExclusiveGlobalTimeMachine(t)
+			tnet := NewTNetwork3(t)
+
+			// all start states are successful
+			tnet.td.GetStartState().Success("")
+			tnet.sniffer1.GetStartState().Success("")
+			tnet.sniffer2.GetStartState().Success("")
+
+			// run the group
+			tnet.Run(0)
+		})
+	})
+	t.Run("TestUnconfirmedRequests", func(t *testing.T) {
+		t.Run("test_local_broadcast", func(t *testing.T) {
+			//Test broadcast for any router.
+			tests.ExclusiveGlobalTimeMachine(t)
+
+			// create a network
+			tnet := NewTNetwork3(t)
+
+			// test device sends request, no response
+			whois, err := NewWhoIsRequest()
+			require.NoError(t, err)
+			whois.SetPDUDestination(NewLocalBroadcast(nil)) // TODO: upstream does this inline
+			tnet.td.GetStartState().Doc("1-1-0").
+				Send(whois, nil).Doc("1-1-1").
+				Timeout(3*time.Second, nil).Doc("1-1-2").
+				Success("")
+
+			// sniffer on network 1 sees the request and the response
+			tnet.sniffer1.GetStartState().Doc("1-2-0").
+				Receive(NewArgs((PDU)(nil)),
+					NewKWArgs(KWPDUData, xtob(
+						"01.80"+ //version, network layer
+							"10 00", // unconfirmed Who-Is
+					),
+					),
+				).Doc("1-2-1").
+				Timeout(3*time.Second, nil).Doc("1-2-2").
+				Success("")
+
+			// nothing received on network 2
+			tnet.sniffer2.GetStartState().Success("")
+
+			// run the group
+			tnet.Run(0)
+		})
+		t.Run("test_remote_broadcast_2", func(t *testing.T) {
+			//Test broadcast, matching device.
+			tests.ExclusiveGlobalTimeMachine(t)
+
+			// create a network
+			tnet := NewTNetwork3(t)
+
+			// test device sends request, no response
+			whois, err := NewWhoIsRouterToNetwork()
+			require.NoError(t, err)
+			whois.SetPDUDestination(NewLocalBroadcast(nil)) // TODO: upstream does this inline
+			tnet.td.GetStartState().Doc("2-1-0").
+				Send(whois, nil).Doc("2-1-1").
+				Success("")
+
+			// sniffer on network 1 sees the request and the response
+			tnet.sniffer1.GetStartState().Doc("2-2-0").
+				Receive(NewArgs((PDU)(nil)),
+					NewKWArgs(KWPDUData, xtob(
+						"01.80.00.00.02", // who is router to network
+					)),
+				).Doc("2-2-1").
+				Receive(NewArgs((PDU)(nil)),
+					NewKWArgs(KWPDUData, xtob(
+						"01.80.01.00.02", // I am router to network
+					)),
+				).Doc("2-2-1").
+				Receive(NewArgs((PDU)(nil)),
+					NewKWArgs(KWPDUData, xtob(
+						"01.20.00.02.00.ff", // remote broadcast goes out
+					)),
+				).Doc("2-2-1").
+				Receive(NewArgs((PDU)(nil)),
+					NewKWArgs(KWPDUData, xtob(
+						"01.08.00.02.01.04"+ // unicast response
+							"10.00.c4.02.00.00.04.22.04.00.91.00.22.03.e7",
+					)),
+				).Doc("2-2-2").
+				Timeout(3*time.Second, nil).Doc("2-2-3").
+				Success("")
+
+			// network 2 sees local broadcast request and unicast response
+			tnet.sniffer2.GetStartState().
+				Receive(NewArgs((PDU)(nil)),
+					NewKWArgs(KWPDUData, xtob(
+						"01.08.00.01.01.01"+ // local broadcast
+							"10.08",
+					)),
+				).Doc("2-3-1").
+				Receive(NewArgs((PDU)(nil)),
+					NewKWArgs(KWPDUData, xtob(
+						"01.08.00.02.01.04"+ // unicast response
+							"10.00.c4.02.00.00.04.22.04.00.91.00.22.03.e7",
+					)),
+				).Doc("2-3-1").
+				Timeout(3*time.Second, nil).Doc("2-3-2").
+				Success("")
+
+			// run the group
+			tnet.Run(0)
+		})
+	})
+	t.Run("TestConfirmedRequests", func(t *testing.T) {
+		t.Skip("implement me") // TODO
+	})
+}
diff --git a/plc4go/internal/bacnetip/tests/test_primitive_data/test_tag_test.go b/plc4go/internal/bacnetip/tests/test_primitive_data/test_tag_test.go
index 1957cd4f7e..9e3814494f 100644
--- a/plc4go/internal/bacnetip/tests/test_primitive_data/test_tag_test.go
+++ b/plc4go/internal/bacnetip/tests/test_primitive_data/test_tag_test.go
@@ -48,7 +48,10 @@ func objDecode(blob []byte) any {
 // Encode the object into a tag, encode it in a PDU, return the data.
 func objEncode(obj any) []byte {
 	tag := Tag()
-	obj.(interface{ Encode(tag bacnetip.Tag) }).Encode(tag)
+	err := obj.(interface{ Encode(arg bacnetip.Arg) error }).Encode(tag)
+	if err != nil {
+		panic(err)
+	}
 	data := PDUData()
 	tag.Encode(data)
 	return data.GetPduData()