From 660c96b7835125ff913f00e6b14d0225f719e25a Mon Sep 17 00:00:00 2001 From: Dmitry Vyazelenko <696855+vyazelenko@users.noreply.github.com> Date: Fri, 29 Mar 2024 16:25:57 +0100 Subject: [PATCH] [Go] Add tests with lower-case enums and bitsets. --- build.gradle | 2 + gocode/Makefile | 2 +- gocode/src/issue505/Issue505_test.go | 29 ++ gocode/src/test973/EventType.go | 107 +++++++ gocode/src/test973/MessageHeader.go | 192 ++++++++++++ gocode/src/test973/SbeMarshalling.go | 283 ++++++++++++++++++ gocode/src/test973/SomeMessage.go | 103 +++++++ gocode/src/test973/test973_test.go | 38 +++ .../golang/GolangGeneratorTest.java | 8 +- .../message-with-lower-case-bitset.xml | 2 +- 10 files changed, 760 insertions(+), 6 deletions(-) create mode 100644 gocode/src/issue505/Issue505_test.go create mode 100644 gocode/src/test973/EventType.go create mode 100644 gocode/src/test973/MessageHeader.go create mode 100644 gocode/src/test973/SbeMarshalling.go create mode 100644 gocode/src/test973/SomeMessage.go create mode 100644 gocode/src/test973/test973_test.go diff --git a/build.gradle b/build.gradle index 0f74a5e005..587bddc0a0 100644 --- a/build.gradle +++ b/build.gradle @@ -700,6 +700,8 @@ tasks.register('generateGolangCodecsWithXSD', JavaExec) { 'sbe-tool/src/test/resources/issue849.xml', 'sbe-tool/src/test/resources/since-deprecated-test-schema.xml', 'sbe-tool/src/test/resources/example-bigendian-test-schema.xml', + 'sbe-tool/src/test/resources/value-ref-with-lower-case-enum.xml', + 'sbe-tool/src/test/resources/message-with-lower-case-bitset.xml', 'gocode/resources/example-composite.xml', 'gocode/resources/group-with-data-extension-schema.xml', 'gocode/resources/simple.xml'] diff --git a/gocode/Makefile b/gocode/Makefile index 456cced904..eebb2b4f38 100644 --- a/gocode/Makefile +++ b/gocode/Makefile @@ -72,7 +72,7 @@ test: $(DEP) go install \ ;done)) (export GOPATH=$(GOPATH) && \ - (for t in baseline-bigendian mktdata group_with_data group_with_data_extension composite_elements composite since-deprecated simple issue435 issue472 issue483 issue488 issue560 issue847 issue848 issue849; do \ + (for t in baseline-bigendian mktdata group_with_data group_with_data_extension composite_elements composite since-deprecated simple issue435 issue472 issue483 issue488 issue560 issue847 issue848 issue849 issue505 test973; do \ cd $(GOPATH)/src/$$t && \ go build && \ go fmt && \ diff --git a/gocode/src/issue505/Issue505_test.go b/gocode/src/issue505/Issue505_test.go new file mode 100644 index 0000000000..5e939a4f0d --- /dev/null +++ b/gocode/src/issue505/Issue505_test.go @@ -0,0 +1,29 @@ +package issue505 + +import ( + "bytes" + "testing" +) + +func TestConstant(t *testing.T) { + message := new(SomeMessage) + SomeMessageInit(message) + + if message.EngineType != EngineType.Gas { + t.Log("message.EngineType != EngineType.Gas:\n", message.EngineType, EngineType.Gas) + t.Fail() + } + + m := NewSbeGoMarshaller() + var buf = new(bytes.Buffer) + var out = *new(SomeMessage) + if err := out.Decode(m, buf, message.SbeSchemaVersion(), message.SbeBlockLength(), true); err != nil { + t.Log("Decoding Error", err) + t.Fail() + } + + if out.EngineType != EngineType.Gas { + t.Log("out.EngineType != EngineType.Gas:\n", out.EngineType, EngineType.Gas) + t.Fail() + } +} diff --git a/gocode/src/test973/EventType.go b/gocode/src/test973/EventType.go new file mode 100644 index 0000000000..fe08752472 --- /dev/null +++ b/gocode/src/test973/EventType.go @@ -0,0 +1,107 @@ +// Generated SBE (Simple Binary Encoding) message codec + +package test973 + +import ( + "io" +) + +type EventType [8]bool +type EventTypeChoiceValue uint8 +type EventTypeChoiceValues struct { + A EventTypeChoiceValue + Bb EventTypeChoiceValue + Ccc EventTypeChoiceValue + D EventTypeChoiceValue + EeEee EventTypeChoiceValue +} + +var EventTypeChoice = EventTypeChoiceValues{0, 1, 2, 3, 4} + +func (e *EventType) Encode(_m *SbeGoMarshaller, _w io.Writer) error { + var wireval uint8 = 0 + for k, v := range e { + if v { + wireval |= (1 << uint(k)) + } + } + return _m.WriteUint8(_w, wireval) +} + +func (e *EventType) Decode(_m *SbeGoMarshaller, _r io.Reader, actingVersion uint16) error { + var wireval uint8 + + if err := _m.ReadUint8(_r, &wireval); err != nil { + return err + } + + var idx uint + for idx = 0; idx < 8; idx++ { + e[idx] = (wireval & (1 << idx)) > 0 + } + return nil +} + +func (EventType) EncodedLength() int64 { + return 1 +} + +func (*EventType) ASinceVersion() uint16 { + return 0 +} + +func (e *EventType) AInActingVersion(actingVersion uint16) bool { + return actingVersion >= e.ASinceVersion() +} + +func (*EventType) ADeprecated() uint16 { + return 0 +} + +func (*EventType) BbSinceVersion() uint16 { + return 0 +} + +func (e *EventType) BbInActingVersion(actingVersion uint16) bool { + return actingVersion >= e.BbSinceVersion() +} + +func (*EventType) BbDeprecated() uint16 { + return 0 +} + +func (*EventType) CccSinceVersion() uint16 { + return 0 +} + +func (e *EventType) CccInActingVersion(actingVersion uint16) bool { + return actingVersion >= e.CccSinceVersion() +} + +func (*EventType) CccDeprecated() uint16 { + return 0 +} + +func (*EventType) DSinceVersion() uint16 { + return 0 +} + +func (e *EventType) DInActingVersion(actingVersion uint16) bool { + return actingVersion >= e.DSinceVersion() +} + +func (*EventType) DDeprecated() uint16 { + return 0 +} + +func (*EventType) EeEeeSinceVersion() uint16 { + return 0 +} + +func (e *EventType) EeEeeInActingVersion(actingVersion uint16) bool { + return actingVersion >= e.EeEeeSinceVersion() +} + +func (*EventType) EeEeeDeprecated() uint16 { + return 0 +} diff --git a/gocode/src/test973/MessageHeader.go b/gocode/src/test973/MessageHeader.go new file mode 100644 index 0000000000..a7ed9008b5 --- /dev/null +++ b/gocode/src/test973/MessageHeader.go @@ -0,0 +1,192 @@ +// Generated SBE (Simple Binary Encoding) message codec + +package test973 + +import ( + "fmt" + "io" + "math" +) + +type MessageHeader struct { + BlockLength uint16 + TemplateId uint16 + SchemaId uint16 + Version uint16 +} + +func (m *MessageHeader) Encode(_m *SbeGoMarshaller, _w io.Writer) error { + if err := _m.WriteUint16(_w, m.BlockLength); err != nil { + return err + } + if err := _m.WriteUint16(_w, m.TemplateId); err != nil { + return err + } + if err := _m.WriteUint16(_w, m.SchemaId); err != nil { + return err + } + if err := _m.WriteUint16(_w, m.Version); err != nil { + return err + } + return nil +} + +func (m *MessageHeader) Decode(_m *SbeGoMarshaller, _r io.Reader, actingVersion uint16) error { + if !m.BlockLengthInActingVersion(actingVersion) { + m.BlockLength = m.BlockLengthNullValue() + } else { + if err := _m.ReadUint16(_r, &m.BlockLength); err != nil { + return err + } + } + if !m.TemplateIdInActingVersion(actingVersion) { + m.TemplateId = m.TemplateIdNullValue() + } else { + if err := _m.ReadUint16(_r, &m.TemplateId); err != nil { + return err + } + } + if !m.SchemaIdInActingVersion(actingVersion) { + m.SchemaId = m.SchemaIdNullValue() + } else { + if err := _m.ReadUint16(_r, &m.SchemaId); err != nil { + return err + } + } + if !m.VersionInActingVersion(actingVersion) { + m.Version = m.VersionNullValue() + } else { + if err := _m.ReadUint16(_r, &m.Version); err != nil { + return err + } + } + return nil +} + +func (m *MessageHeader) RangeCheck(actingVersion uint16, schemaVersion uint16) error { + if m.BlockLengthInActingVersion(actingVersion) { + if m.BlockLength < m.BlockLengthMinValue() || m.BlockLength > m.BlockLengthMaxValue() { + return fmt.Errorf("Range check failed on m.BlockLength (%v < %v > %v)", m.BlockLengthMinValue(), m.BlockLength, m.BlockLengthMaxValue()) + } + } + if m.TemplateIdInActingVersion(actingVersion) { + if m.TemplateId < m.TemplateIdMinValue() || m.TemplateId > m.TemplateIdMaxValue() { + return fmt.Errorf("Range check failed on m.TemplateId (%v < %v > %v)", m.TemplateIdMinValue(), m.TemplateId, m.TemplateIdMaxValue()) + } + } + if m.SchemaIdInActingVersion(actingVersion) { + if m.SchemaId < m.SchemaIdMinValue() || m.SchemaId > m.SchemaIdMaxValue() { + return fmt.Errorf("Range check failed on m.SchemaId (%v < %v > %v)", m.SchemaIdMinValue(), m.SchemaId, m.SchemaIdMaxValue()) + } + } + if m.VersionInActingVersion(actingVersion) { + if m.Version < m.VersionMinValue() || m.Version > m.VersionMaxValue() { + return fmt.Errorf("Range check failed on m.Version (%v < %v > %v)", m.VersionMinValue(), m.Version, m.VersionMaxValue()) + } + } + return nil +} + +func MessageHeaderInit(m *MessageHeader) { + return +} + +func (*MessageHeader) EncodedLength() int64 { + return 8 +} + +func (*MessageHeader) BlockLengthMinValue() uint16 { + return 0 +} + +func (*MessageHeader) BlockLengthMaxValue() uint16 { + return math.MaxUint16 - 1 +} + +func (*MessageHeader) BlockLengthNullValue() uint16 { + return math.MaxUint16 +} + +func (*MessageHeader) BlockLengthSinceVersion() uint16 { + return 0 +} + +func (m *MessageHeader) BlockLengthInActingVersion(actingVersion uint16) bool { + return actingVersion >= m.BlockLengthSinceVersion() +} + +func (*MessageHeader) BlockLengthDeprecated() uint16 { + return 0 +} + +func (*MessageHeader) TemplateIdMinValue() uint16 { + return 0 +} + +func (*MessageHeader) TemplateIdMaxValue() uint16 { + return math.MaxUint16 - 1 +} + +func (*MessageHeader) TemplateIdNullValue() uint16 { + return math.MaxUint16 +} + +func (*MessageHeader) TemplateIdSinceVersion() uint16 { + return 0 +} + +func (m *MessageHeader) TemplateIdInActingVersion(actingVersion uint16) bool { + return actingVersion >= m.TemplateIdSinceVersion() +} + +func (*MessageHeader) TemplateIdDeprecated() uint16 { + return 0 +} + +func (*MessageHeader) SchemaIdMinValue() uint16 { + return 0 +} + +func (*MessageHeader) SchemaIdMaxValue() uint16 { + return math.MaxUint16 - 1 +} + +func (*MessageHeader) SchemaIdNullValue() uint16 { + return math.MaxUint16 +} + +func (*MessageHeader) SchemaIdSinceVersion() uint16 { + return 0 +} + +func (m *MessageHeader) SchemaIdInActingVersion(actingVersion uint16) bool { + return actingVersion >= m.SchemaIdSinceVersion() +} + +func (*MessageHeader) SchemaIdDeprecated() uint16 { + return 0 +} + +func (*MessageHeader) VersionMinValue() uint16 { + return 0 +} + +func (*MessageHeader) VersionMaxValue() uint16 { + return math.MaxUint16 - 1 +} + +func (*MessageHeader) VersionNullValue() uint16 { + return math.MaxUint16 +} + +func (*MessageHeader) VersionSinceVersion() uint16 { + return 0 +} + +func (m *MessageHeader) VersionInActingVersion(actingVersion uint16) bool { + return actingVersion >= m.VersionSinceVersion() +} + +func (*MessageHeader) VersionDeprecated() uint16 { + return 0 +} diff --git a/gocode/src/test973/SbeMarshalling.go b/gocode/src/test973/SbeMarshalling.go new file mode 100644 index 0000000000..76cd098c51 --- /dev/null +++ b/gocode/src/test973/SbeMarshalling.go @@ -0,0 +1,283 @@ +// Copyright (C) 2017 MarketFactory, Inc +// +// Licensed 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. +// +// This file provides a simple bespoke marshalling layer for the +// standard binary encoding golang backend and is part of: +// +// https://github.com/real-logic/simple-binary-encoding + +package test973 + +import ( + "io" + "math" +) + +// Allocate via NewSbeGoMarshaller to initialize +type SbeGoMarshaller struct { + b8 []byte // statically allocated tmp space to avoid alloc + b1 []byte // previously created slice into b to save time + b2 []byte // previously created slice into b to save time + b4 []byte // previously created slice into b to save time +} + +func NewSbeGoMarshaller() *SbeGoMarshaller { + var m SbeGoMarshaller + m.b8 = make([]byte, 8) + m.b1 = m.b8[:1] + m.b2 = m.b8[:2] + m.b4 = m.b8[:4] + return &m +} + +// The "standard" MessageHeader. +// +// Most applications will use this as it's the default and optimized +// although it's possible to change it by: +// a) using a different sized BlockLength, or +// b) adding arbitrary fields +// +// If the MessageHeader is not "standard" then you can use the +// generated MessageHeader type in MessageHeader.go otherwise we +// recommend this one. +type SbeGoMessageHeader struct { + BlockLength uint16 + TemplateId uint16 + SchemaId uint16 + Version uint16 +} + +func (m SbeGoMessageHeader) Encode(_m *SbeGoMarshaller, _w io.Writer) error { + _m.b8[0] = byte(m.BlockLength) + _m.b8[1] = byte(m.BlockLength >> 8) + _m.b8[2] = byte(m.TemplateId) + _m.b8[3] = byte(m.TemplateId >> 8) + _m.b8[4] = byte(m.SchemaId) + _m.b8[5] = byte(m.SchemaId >> 8) + _m.b8[6] = byte(m.Version) + _m.b8[7] = byte(m.Version >> 8) + if _, err := _w.Write(_m.b8); err != nil { + return err + } + return nil +} + +func (m *SbeGoMessageHeader) Decode(_m *SbeGoMarshaller, _r io.Reader) error { + if _, err := io.ReadFull(_r, _m.b8); err != nil { + return err + } + m.BlockLength = uint16(_m.b8[0]) | uint16(_m.b8[1])<<8 + m.TemplateId = uint16(_m.b8[2]) | uint16(_m.b8[3])<<8 + m.SchemaId = uint16(_m.b8[4]) | uint16(_m.b8[5])<<8 + m.Version = uint16(_m.b8[6]) | uint16(_m.b8[7])<<8 + return nil +} + +func (m *SbeGoMarshaller) WriteUint8(w io.Writer, v uint8) error { + m.b1[0] = byte(v) + _, err := w.Write(m.b1) + return err +} + +func (m *SbeGoMarshaller) WriteUint16(w io.Writer, v uint16) error { + m.b2[0] = byte(v) + m.b2[1] = byte(v >> 8) + _, err := w.Write(m.b2) + return err +} + +func (m *SbeGoMarshaller) WriteUint32(w io.Writer, v uint32) error { + m.b4[0] = byte(v) + m.b4[1] = byte(v >> 8) + m.b4[2] = byte(v >> 16) + m.b4[3] = byte(v >> 24) + _, err := w.Write(m.b4) + return err +} + +func (m *SbeGoMarshaller) WriteUint64(w io.Writer, v uint64) error { + m.b8[0] = byte(v) + m.b8[1] = byte(v >> 8) + m.b8[2] = byte(v >> 16) + m.b8[3] = byte(v >> 24) + m.b8[4] = byte(v >> 32) + m.b8[5] = byte(v >> 40) + m.b8[6] = byte(v >> 48) + m.b8[7] = byte(v >> 56) + _, err := w.Write(m.b8) + return err +} + +func (m *SbeGoMarshaller) WriteInt8(w io.Writer, v int8) error { + m.b1[0] = byte(v) + _, err := w.Write(m.b1) + return err +} + +func (m *SbeGoMarshaller) WriteInt16(w io.Writer, v int16) error { + m.b2[0] = byte(v) + m.b2[1] = byte(v >> 8) + _, err := w.Write(m.b2) + return err +} + +func (m *SbeGoMarshaller) WriteInt32(w io.Writer, v int32) error { + m.b4[0] = byte(v) + m.b4[1] = byte(v >> 8) + m.b4[2] = byte(v >> 16) + m.b4[3] = byte(v >> 24) + _, err := w.Write(m.b4) + return err +} + +func (m *SbeGoMarshaller) WriteInt64(w io.Writer, v int64) error { + m.b8[0] = byte(v) + m.b8[1] = byte(v >> 8) + m.b8[2] = byte(v >> 16) + m.b8[3] = byte(v >> 24) + m.b8[4] = byte(v >> 32) + m.b8[5] = byte(v >> 40) + m.b8[6] = byte(v >> 48) + m.b8[7] = byte(v >> 56) + _, err := w.Write(m.b8) + return err +} + +func (m *SbeGoMarshaller) WriteFloat32(w io.Writer, v float32) error { + u32 := math.Float32bits(v) + m.b4[0] = byte(u32) + m.b4[1] = byte(u32 >> 8) + m.b4[2] = byte(u32 >> 16) + m.b4[3] = byte(u32 >> 24) + _, err := w.Write(m.b4) + return err +} + +func (m *SbeGoMarshaller) WriteFloat64(w io.Writer, v float64) error { + u64 := math.Float64bits(v) + m.b8[0] = byte(u64) + m.b8[1] = byte(u64 >> 8) + m.b8[2] = byte(u64 >> 16) + m.b8[3] = byte(u64 >> 24) + m.b8[4] = byte(u64 >> 32) + m.b8[5] = byte(u64 >> 40) + m.b8[6] = byte(u64 >> 48) + m.b8[7] = byte(u64 >> 56) + _, err := w.Write(m.b8) + return err +} + +func (m *SbeGoMarshaller) WriteBytes(w io.Writer, v []byte) error { + _, err := w.Write(v) + return err +} + +func (m *SbeGoMarshaller) ReadUint8(r io.Reader, v *uint8) error { + if _, err := io.ReadFull(r, m.b1); err != nil { + return err + } + *v = uint8(m.b1[0]) + return nil +} + +func (m *SbeGoMarshaller) ReadUint16(r io.Reader, v *uint16) error { + if _, err := io.ReadFull(r, m.b2); err != nil { + return err + } + *v = (uint16(m.b2[0]) | uint16(m.b2[1])<<8) + return nil +} + +func (m *SbeGoMarshaller) ReadUint32(r io.Reader, v *uint32) error { + if _, err := io.ReadFull(r, m.b4); err != nil { + return err + } + *v = (uint32(m.b4[0]) | uint32(m.b4[1])<<8 | + uint32(m.b4[2])<<16 | uint32(m.b4[3])<<24) + return nil +} + +func (m *SbeGoMarshaller) ReadUint64(r io.Reader, v *uint64) error { + if _, err := io.ReadFull(r, m.b8); err != nil { + return err + } + *v = (uint64(m.b8[0]) | uint64(m.b8[1])<<8 | + uint64(m.b8[2])<<16 | uint64(m.b8[3])<<24 | + uint64(m.b8[4])<<32 | uint64(m.b8[5])<<40 | + uint64(m.b8[6])<<48 | uint64(m.b8[7])<<56) + return nil +} + +func (m *SbeGoMarshaller) ReadInt8(r io.Reader, v *int8) error { + if _, err := io.ReadFull(r, m.b1); err != nil { + return err + } + *v = int8(m.b1[0]) + return nil +} + +func (m *SbeGoMarshaller) ReadInt16(r io.Reader, v *int16) error { + if _, err := io.ReadFull(r, m.b2); err != nil { + return err + } + *v = (int16(m.b2[0]) | int16(m.b2[1])<<8) + return nil +} + +func (m *SbeGoMarshaller) ReadInt32(r io.Reader, v *int32) error { + if _, err := io.ReadFull(r, m.b4); err != nil { + return err + } + *v = (int32(m.b4[0]) | int32(m.b4[1])<<8 | + int32(m.b4[2])<<16 | int32(m.b4[3])<<24) + return nil +} + +func (m *SbeGoMarshaller) ReadInt64(r io.Reader, v *int64) error { + if _, err := io.ReadFull(r, m.b8); err != nil { + return err + } + *v = (int64(m.b8[0]) | int64(m.b8[1])<<8 | + int64(m.b8[2])<<16 | int64(m.b8[3])<<24 | + int64(m.b8[4])<<32 | int64(m.b8[5])<<40 | + int64(m.b8[6])<<48 | int64(m.b8[7])<<56) + return nil +} + +func (m *SbeGoMarshaller) ReadFloat32(r io.Reader, v *float32) error { + if _, err := io.ReadFull(r, m.b4); err != nil { + return err + } + *v = math.Float32frombits(uint32(m.b4[0]) | uint32(m.b4[1])<<8 | + uint32(m.b4[2])<<16 | uint32(m.b4[3])<<24) + return nil +} + +func (m *SbeGoMarshaller) ReadFloat64(r io.Reader, v *float64) error { + if _, err := io.ReadFull(r, m.b8); err != nil { + return err + } + *v = math.Float64frombits(uint64(m.b8[0]) | uint64(m.b8[1])<<8 | + uint64(m.b8[2])<<16 | uint64(m.b8[3])<<24 | + uint64(m.b8[4])<<32 | uint64(m.b8[5])<<40 | + uint64(m.b8[6])<<48 | uint64(m.b8[7])<<56) + return nil +} + +func (m *SbeGoMarshaller) ReadBytes(r io.Reader, b []byte) error { + if _, err := io.ReadFull(r, b); err != nil { + return err + } + return nil +} diff --git a/gocode/src/test973/SomeMessage.go b/gocode/src/test973/SomeMessage.go new file mode 100644 index 0000000000..460c5e89d1 --- /dev/null +++ b/gocode/src/test973/SomeMessage.go @@ -0,0 +1,103 @@ +// Generated SBE (Simple Binary Encoding) message codec + +package test973 + +import ( + "io" + "io/ioutil" +) + +type SomeMessage struct { + MyEvent EventType +} + +func (s *SomeMessage) Encode(_m *SbeGoMarshaller, _w io.Writer, doRangeCheck bool) error { + if doRangeCheck { + if err := s.RangeCheck(s.SbeSchemaVersion(), s.SbeSchemaVersion()); err != nil { + return err + } + } + if err := s.MyEvent.Encode(_m, _w); err != nil { + return err + } + return nil +} + +func (s *SomeMessage) Decode(_m *SbeGoMarshaller, _r io.Reader, actingVersion uint16, blockLength uint16, doRangeCheck bool) error { + if s.MyEventInActingVersion(actingVersion) { + if err := s.MyEvent.Decode(_m, _r, actingVersion); err != nil { + return err + } + } + if actingVersion > s.SbeSchemaVersion() && blockLength > s.SbeBlockLength() { + io.CopyN(ioutil.Discard, _r, int64(blockLength-s.SbeBlockLength())) + } + if doRangeCheck { + if err := s.RangeCheck(actingVersion, s.SbeSchemaVersion()); err != nil { + return err + } + } + return nil +} + +func (s *SomeMessage) RangeCheck(actingVersion uint16, schemaVersion uint16) error { + return nil +} + +func SomeMessageInit(s *SomeMessage) { + return +} + +func (*SomeMessage) SbeBlockLength() (blockLength uint16) { + return 1 +} + +func (*SomeMessage) SbeTemplateId() (templateId uint16) { + return 1 +} + +func (*SomeMessage) SbeSchemaId() (schemaId uint16) { + return 973 +} + +func (*SomeMessage) SbeSchemaVersion() (schemaVersion uint16) { + return 0 +} + +func (*SomeMessage) SbeSemanticType() (semanticType []byte) { + return []byte("") +} + +func (*SomeMessage) SbeSemanticVersion() (semanticVersion string) { + return "1.0" +} + +func (*SomeMessage) MyEventId() uint16 { + return 1 +} + +func (*SomeMessage) MyEventSinceVersion() uint16 { + return 0 +} + +func (s *SomeMessage) MyEventInActingVersion(actingVersion uint16) bool { + return actingVersion >= s.MyEventSinceVersion() +} + +func (*SomeMessage) MyEventDeprecated() uint16 { + return 0 +} + +func (*SomeMessage) MyEventMetaAttribute(meta int) string { + switch meta { + case 1: + return "" + case 2: + return "" + case 3: + return "" + case 4: + return "required" + } + return "" +} diff --git a/gocode/src/test973/test973_test.go b/gocode/src/test973/test973_test.go new file mode 100644 index 0000000000..418550b473 --- /dev/null +++ b/gocode/src/test973/test973_test.go @@ -0,0 +1,38 @@ +package test973 + +import ( + "bytes" + "testing" +) + +func TestEncodeDecode(t *testing.T) { + message := new(SomeMessage) + SomeMessageInit(message) + + m := NewSbeGoMarshaller() + var buf = new(bytes.Buffer) + + message.MyEvent[EventTypeChoice.A] = true + message.MyEvent[EventTypeChoice.Ccc] = true + + if err := message.Encode(m, buf, true); err != nil { + t.Log("Encoding Error", err) + t.Fail() + } + + var out = *new(SomeMessage) + if err := out.Decode(m, buf, message.SbeSchemaVersion(), message.SbeBlockLength(), true); err != nil { + t.Log("Decoding Error", err) + t.Fail() + } + + if out.MyEvent != message.MyEvent { + t.Log("Value mismatch: ", out.MyEvent, message.MyEvent) + t.Fail() + } + + if !out.MyEvent[EventTypeChoice.A] || !out.MyEvent[EventTypeChoice.Ccc] || out.MyEvent[EventTypeChoice.EeEee] { + t.Log("Sanity check failed: ", out.MyEvent) + t.Fail() + } +} diff --git a/sbe-tool/src/test/java/uk/co/real_logic/sbe/generation/golang/GolangGeneratorTest.java b/sbe-tool/src/test/java/uk/co/real_logic/sbe/generation/golang/GolangGeneratorTest.java index 14ce4087c8..af647727f2 100644 --- a/sbe-tool/src/test/java/uk/co/real_logic/sbe/generation/golang/GolangGeneratorTest.java +++ b/sbe-tool/src/test/java/uk/co/real_logic/sbe/generation/golang/GolangGeneratorTest.java @@ -268,10 +268,10 @@ void shouldUseUpperCaseTypeNamesWhenReferencingBitSet() throws Exception final GolangGenerator generator = new GolangGenerator(ir, outputManager); generator.generate(); - final String eventTypeSource = outputManager.getSource("test.EventType").toString(); + final String eventTypeSource = outputManager.getSource("test973.EventType").toString(); assertEquals("// Generated SBE (Simple Binary Encoding) message codec\n" + "\n" + - "package test\n" + + "package test973\n" + "\n" + "import (\n" + "\t\"io\"\n" + @@ -377,10 +377,10 @@ void shouldUseUpperCaseTypeNamesWhenReferencingBitSet() throws Exception "\treturn 0\n" + "}\n", eventTypeSource); - final String messageSource = outputManager.getSource("test.SomeMessage").toString(); + final String messageSource = outputManager.getSource("test973.SomeMessage").toString(); assertEquals("// Generated SBE (Simple Binary Encoding) message codec\n" + "\n" + - "package test\n" + + "package test973\n" + "\n" + "import (\n" + "\t\"io\"\n" + diff --git a/sbe-tool/src/test/resources/message-with-lower-case-bitset.xml b/sbe-tool/src/test/resources/message-with-lower-case-bitset.xml index ba08af1fc7..a160ddbceb 100644 --- a/sbe-tool/src/test/resources/message-with-lower-case-bitset.xml +++ b/sbe-tool/src/test/resources/message-with-lower-case-bitset.xml @@ -1,6 +1,6 @@