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()