From 190a89fbb3215e9623d8b182bd30a4aa9729f0bb Mon Sep 17 00:00:00 2001 From: Sasha Koshka Date: Mon, 13 Oct 2025 16:16:57 -0400 Subject: [PATCH 01/10] generate: Parse doc comments --- generate/parse.go | 53 +++++++++++++++++++++++++++++++----------- generate/parse_test.go | 2 +- 2 files changed, 40 insertions(+), 15 deletions(-) diff --git a/generate/parse.go b/generate/parse.go index f43723f..0b77b94 100644 --- a/generate/parse.go +++ b/generate/parse.go @@ -1,6 +1,7 @@ package generate import "io" +import "strings" import "strconv" import "git.tebibyte.media/sashakoshka/goparse" @@ -47,18 +48,28 @@ func (this *parser) parse() error { } func (this *parser) parseTopLevel() error { - err := this.ExpectDesc("message or typedef", TokenMethod, TokenIdent) - if err != nil { return err } - if this.EOF() { return nil } + doc := "" + for { + err := this.ExpectDesc("message or typedef", TokenMethod, TokenIdent, TokenComment) + if err != nil { return err } + if this.EOF() { return nil } + if this.Kind() == TokenComment { + if doc != "" { doc += "\n" } + doc += this.parseComment(this.Value()) + this.Next() + } else { + break + } + } switch this.Kind() { - case TokenMethod: return this.parseMessage() - case TokenIdent: return this.parseTypedef() + case TokenMethod: return this.parseMessage(doc) + case TokenIdent: return this.parseTypedef(doc) } panic("bug") } -func (this *parser) parseMessage() error { +func (this *parser) parseMessage(doc string) error { err := this.Expect(TokenMethod) if err != nil { return err } method, err := this.parseHexNumber(this.Value(), 0xFFFF) @@ -72,13 +83,13 @@ func (this *parser) parseMessage() error { if err != nil { return err } this.protocol.Messages[uint16(method)] = Message { Name: name, - // TODO: doc + Doc: doc, Type: typ, } return nil } -func (this *parser) parseTypedef() error { +func (this *parser) parseTypedef(doc string) error { err := this.Expect(TokenIdent) if err != nil { return err } name := this.Value() @@ -87,7 +98,7 @@ func (this *parser) parseTypedef() error { typ, err := this.parseType() if err != nil { return err } this.protocol.Types[name] = Typedef { - // TODO: doc + Doc: doc, Type: typ, } return nil @@ -161,12 +172,22 @@ func (this *parser) parseTypeTable() (TypeTableDefined, error) { Fields: make(map[uint16] Field), } for { - err := this.ExpectDesc("table field", TokenKey, TokenRBrace) - if err != nil { return TypeTableDefined { }, err } + doc := "" + for { + err := this.ExpectDesc("table field", TokenKey, TokenRBrace, TokenComment) + if err != nil { return TypeTableDefined { }, err } + if this.Kind() == TokenComment { + if doc != "" { doc += "\n" } + doc += this.parseComment(this.Value()) + this.Next() + } else { + break + } + } if this.Is(TokenRBrace) { break } - key, field, err := this.parseField() + key, field, err := this.parseField(doc) if err != nil { return TypeTableDefined { }, err } typ.Fields[key] = field err = this.Expect(TokenComma, TokenRBrace) @@ -182,7 +203,7 @@ func (this *parser) parseTypeTable() (TypeTableDefined, error) { return typ, nil } -func (this *parser) parseField() (uint16, Field, error) { +func (this *parser) parseField(doc string) (uint16, Field, error) { err := this.Expect(TokenKey) if err != nil { return 0, Field { }, err } key, err := this.parseHexNumber(this.Value(), 0xFFFF) @@ -196,7 +217,7 @@ func (this *parser) parseField() (uint16, Field, error) { if err != nil { return 0, Field { }, err } return uint16(key), Field { Name: name, - // TODO: doc + Doc: doc, Type: typ, }, nil } @@ -211,3 +232,7 @@ func (this *parser) parseHexNumber(input string, maxValue int64) (int64, error) } return number, nil } + +func (this *parser) parseComment(input string) string { + return strings.TrimPrefix(strings.TrimPrefix(input, "//"), " ") +} diff --git a/generate/parse_test.go b/generate/parse_test.go index 7ff4243..4a5c3ba 100644 --- a/generate/parse_test.go +++ b/generate/parse_test.go @@ -9,7 +9,7 @@ func TestParse(test *testing.T) { correct := defaultProtocol() correct.Messages[0x0000] = Message { Name: "Connect", - Doc: "Connect is sent from the client to the server as the first message of an\n authenticated transaction.", + Doc: "Connect is sent from the client to the server as the first message of an\nauthenticated transaction.", Type: TypeTableDefined { Fields: map[uint16] Field { 0x0000: Field { Name: "Name", Type: TypeString { } }, -- 2.50.1 From 5d5d3fd31c222708247c3701c72ee5e9d37c31aa Mon Sep 17 00:00:00 2001 From: Sasha Koshka Date: Mon, 13 Oct 2025 17:29:27 -0400 Subject: [PATCH 02/10] generate: Emit doc comments (in theory) --- generate/generate.go | 40 +++++++++++++++++++++++++++------------- 1 file changed, 27 insertions(+), 13 deletions(-) diff --git a/generate/generate.go b/generate/generate.go index bef34a0..f1bfbcf 100644 --- a/generate/generate.go +++ b/generate/generate.go @@ -116,12 +116,16 @@ func (this *Generator) generateTypedef(name string, typedef Typedef) (n int, err typ := typedef.Type // type definition - // TODO doc - nn, err := this.iprintf( - "\n// %s represents the protocol data type %s.\n", - name, name) - n += nn; if err != nil { return n, err } - nn, err = this.iprintf("type %s ", name) + if typedef.Doc == "" { + nn, err := this.iprintf( + "\n// %s represents the protocol data type %s.\n", + name, name) + n += nn; if err != nil { return n, err } + } else { + nn, err := this.iprintf("\n%s\n", this.formatComment(typedef.Doc)) + n += nn; if err != nil { return n, err } + } + nn, err := this.iprintf("type %s ", name) n += nn; if err != nil { return n, err } nn, err = this.generateType(typ) n += nn; if err != nil { return n, err } @@ -211,11 +215,16 @@ func (this *Generator) generateTypedef(name string, typedef Typedef) (n int, err // generateMessage generates the structure, as well as encoding decoding // functions for the given message. func (this *Generator) generateMessage(method uint16, message Message) (n int, err error) { - // TODO doc - nn, err := this.iprintf( - "\n// %s represents the protocol message M%04X %s.\n", - message.Name, method, message.Name) - nn, err = this.iprintf("type %s ", this.resolveMessageName(message.Name)) + if message.Doc == "" { + nn, err := this.iprintf( + "\n// %s represents the protocol message M%04X %s.\n", + message.Name, method, message.Name) + n += nn; if err != nil { return n, err } + } else { + nn, err := this.iprintf("\n%s\n", this.formatComment(message.Doc)) + n += nn; if err != nil { return n, err } + } + nn, err := this.iprintf("type %s ", this.resolveMessageName(message.Name)) n += nn; if err != nil { return n, err } nn, err = this.generateType(message.Type) n += nn; if err != nil { return n, err } @@ -1094,8 +1103,9 @@ func (this *Generator) generateTypeTableDefined(typ TypeTableDefined) (n int, er for _, key := range slices.Sorted(maps.Keys(typ.Fields)) { field := typ.Fields[key] - // TODO doc - nn, err := this.iprintf("%s ", field.Name) + nn, err := this.iprintf("%s\n", this.formatComment(field.Doc)) + n += nn; if err != nil { return n, err } + nn, err = this.iprintf("%s ", field.Name) n += nn; if err != nil { return n, err } nn, err = this.generateType(field.Type) n += nn; if err != nil { return n, err } @@ -1180,6 +1190,10 @@ func (this *Generator) iprintf(format string, args ...any) (n int, err error) { return fmt.Fprintf(this.Output, this.indent() + format, args...) } +func (this *Generator) formatComment(comment string) string { + return "// " + strings.ReplaceAll(comment, "\n", "\n" + this.indent() + "// ") +} + func (this *Generator) resolveMessageName(message string) string { return "Message" + message } -- 2.50.1 From cdfccb0f1c400efa1822bae003d490a290fa6db3 Mon Sep 17 00:00:00 2001 From: Sasha Koshka Date: Tue, 14 Oct 2025 23:17:59 -0400 Subject: [PATCH 03/10] design: Add Bool type --- design/pdl-language.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/design/pdl-language.md b/design/pdl-language.md index 914ea6a..0b45c63 100644 --- a/design/pdl-language.md +++ b/design/pdl-language.md @@ -6,7 +6,7 @@ PDL allows defining a protocol using HOPP and TAPE. | Syntax | TN | CN | Description | ---------- | ------- | -: | ----------- -| I5 | SI | | +| I5 | SI | | | I8 | LSI | 0 | | I16 | LSI | 1 | | I32 | LSI | 3 | @@ -25,6 +25,7 @@ PDL allows defining a protocol using HOPP and TAPE. | F64 | FP | 7 | | F128[^2] | FP | 15 | | F256[^2] | FP | 31 | +| Bool | SI | | | String | SBA/LBA | * | UTF-8 string | Buffer | SBA/LBA | * | Byte array | []\ | OTA | * | Array of any type[^1] -- 2.50.1 From 2ee954e18fb81870307b97805dadbd4e3e97faa7 Mon Sep 17 00:00:00 2001 From: Sasha Koshka Date: Wed, 15 Oct 2025 00:31:30 -0400 Subject: [PATCH 04/10] generate: Add bool data structure --- generate/protocol.go | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/generate/protocol.go b/generate/protocol.go index dd83bec..a733f1b 100644 --- a/generate/protocol.go +++ b/generate/protocol.go @@ -49,6 +49,12 @@ func (typ TypeFloat) String() string { return fmt.Sprintf("F%d", typ.Bits) } +type TypeBool struct { } + +func (TypeBool) String() string { + return "Bool" +} + type TypeString struct { } func (TypeString) String() string { -- 2.50.1 From 770f6b05b445622c2f8ba0d4b1bdd5276ab243a1 Mon Sep 17 00:00:00 2001 From: Sasha Koshka Date: Wed, 15 Oct 2025 00:31:54 -0400 Subject: [PATCH 05/10] generate: Parse Bool type --- generate/parse.go | 1 + generate/parse_test.go | 2 ++ 2 files changed, 3 insertions(+) diff --git a/generate/parse.go b/generate/parse.go index 0b77b94..794c103 100644 --- a/generate/parse.go +++ b/generate/parse.go @@ -132,6 +132,7 @@ func (this *parser) parseType() (Type, error) { case "Buffer": return TypeBuffer { }, this.Next() case "Table": return TypeTable { }, this.Next() case "Any": return TypeAny { }, this.Next() + case "Bool": return TypeBool { }, this.Next() } return this.parseTypeNamed() case TokenLBracket: diff --git a/generate/parse_test.go b/generate/parse_test.go index 4a5c3ba..eb923cf 100644 --- a/generate/parse_test.go +++ b/generate/parse_test.go @@ -33,6 +33,7 @@ func TestParse(test *testing.T) { 0x0000: Field { Name: "Name", Type: TypeString { } }, 0x0001: Field { Name: "Bio", Type: TypeString { } }, 0x0002: Field { Name: "Followers", Type: TypeInt { Bits: 32 } }, + 0x0003: Field { Name: "Bouncy", Type: TypeBool { } }, }, }, } @@ -61,6 +62,7 @@ func TestParse(test *testing.T) { 0000 Name String, 0001 Bio String, 0002 Followers U32, + 0003 Bouncy Bool, } Anything Any -- 2.50.1 From 13d35e54f54973300ce67b932d671bbbbe9a71dd Mon Sep 17 00:00:00 2001 From: Sasha Koshka Date: Wed, 15 Oct 2025 00:58:00 -0400 Subject: [PATCH 06/10] generate: Include bool in tests --- generate/generate_test.go | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/generate/generate_test.go b/generate/generate_test.go index a01a776..25e3384 100644 --- a/generate/generate_test.go +++ b/generate/generate_test.go @@ -59,6 +59,7 @@ func init() { 0x000C: Field { Name: "NI16",Type: TypeInt { Bits: 16, Signed: true } }, 0x000D: Field { Name: "NI32",Type: TypeInt { Bits: 32, Signed: true } }, 0x000E: Field { Name: "NI64",Type: TypeInt { Bits: 64, Signed: true } }, + 0x000F: Field { Name: "Bool",Type: TypeBool { } }, }, }, } @@ -201,10 +202,11 @@ func TestGenerateRunEncodeDecode(test *testing.T) { NI16: -0x34C9, NI32: -0x10E134C9, NI64: -0x639109BC10E134C9, + Bool: true, } testEncodeDecode( &messageIntegers, - tu.S(0xE0, 13).AddVar( + tu.S(0xE0, 14).AddVar( []byte { 0x00, 0x00, 0x13 }, []byte { 0x00, 0x01, 0x20, 0xC9 }, []byte { 0x00, 0x02, 0x21, 0x34, 0xC9 }, @@ -218,6 +220,7 @@ func TestGenerateRunEncodeDecode(test *testing.T) { []byte { 0x00, 0x0C, 0x41, 0xCB, 0x37 }, []byte { 0x00, 0x0D, 0x43, 0xEF, 0x1E, 0xCB, 0x37 }, []byte { 0x00, 0x0E, 0x47, 0x9C, 0x6E, 0xF6, 0x43, 0xEF, 0x1E, 0xCB, 0x37 }, + []byte { 0x00, 0x0F, 0x01 }, )) log.Println("MessageDynamic") messageDynamic := MessageDynamic { -- 2.50.1 From 00b0f13d3eb865705d6e141b46a94d901ec77701 Mon Sep 17 00:00:00 2001 From: Sasha Koshka Date: Wed, 15 Oct 2025 00:58:14 -0400 Subject: [PATCH 07/10] generate: Implement bool in static system --- generate/generate.go | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/generate/generate.go b/generate/generate.go index f1bfbcf..2c64b33 100644 --- a/generate/generate.go +++ b/generate/generate.go @@ -47,6 +47,15 @@ func canAssign(destination, source tape.Tag) bool { } return false } + +// boolInt converts a bool to an integer. +func boolInt(input bool) int { + if input { + return 1 + } else { + return 0 + } +} ` // Generator converts protocols into Go code. @@ -315,6 +324,9 @@ func (this *Generator) generateMessage(method uint16, message Message) (n int, e // - nn int func (this *Generator) generateEncodeValue(typ Type, valueSource, tagSource string) (n int, err error) { switch typ := typ.(type) { + case TypeBool: + // SI: (none) + // SI stores the value in the tag, so we write nothing here case TypeInt: // SI: (none) // LI/LSI: @@ -518,6 +530,11 @@ func (this *Generator) generateEncodeValue(typ Type, valueSource, tagSource stri // for [Generator.generateDecodeBranch]. func (this *Generator) generateDecodeValue(typ Type, typeName, valueSource, tagSource string) (n int, err error) { switch typ := typ.(type) { + case TypeBool: + // SI: (none) + // SI stores the value in the tag + nn, err := this.iprintf("*%s = %s.CN() > 0\n", valueSource, tagSource) + n += nn; if err != nil { return n, err } case TypeInt: // SI: (none) // LI/LSI: @@ -944,6 +961,9 @@ func (this *Generator) generateBareErrorCheck() (n int, err error) { func (this *Generator) generateTag(typ Type, source string) (tagVar string, n int, err error) { tagVar = this.newTemporaryVar("tag") switch typ := typ.(type) { + case TypeBool: + nn, err := this.iprintf("%s := tape.SI.WithCN(boolInt(bool(%s)))\n", tagVar, source) + n += nn; if err != nil { return tagVar, n, err } case TypeInt: if typ.Bits <= 5 { nn, err := this.iprintf("%s := tape.SI.WithCN(int(%s))\n", tagVar, source) @@ -997,6 +1017,9 @@ func (this *Generator) generateTag(typ Type, source string) (tagVar string, n in // information is chosen. func (this *Generator) generateTN(typ Type) (n int, err error) { switch typ := typ.(type) { + case TypeBool: + nn, err := this.printf("tape.SI") + n += nn; if err != nil { return n, err } case TypeInt: if typ.Bits <= 5 { nn, err := this.printf("tape.SI") @@ -1040,6 +1063,9 @@ func (this *Generator) generateTN(typ Type) (n int, err error) { func (this *Generator) generateType(typ Type) (n int, err error) { switch typ := typ.(type) { + case TypeBool: + nn, err := this.printf("bool") + n += nn; if err != nil { return n, err } case TypeInt: if err := this.validateIntBitSize(typ.Bits); err != nil { return n, err -- 2.50.1 From c511ebcb1533ca1d0cfc81116561ff24ee9cf2e6 Mon Sep 17 00:00:00 2001 From: Sasha Koshka Date: Wed, 15 Oct 2025 01:07:39 -0400 Subject: [PATCH 08/10] tape: Add bools to tests --- tape/dynamic_test.go | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/tape/dynamic_test.go b/tape/dynamic_test.go index 1023063..969183f 100644 --- a/tape/dynamic_test.go +++ b/tape/dynamic_test.go @@ -15,6 +15,8 @@ var samplePayloads = [][]byte { /* uint16 */ []byte { byte(LI.WithCN(1)), 0x45, 0x67 }, /* uint32 */ []byte { byte(LI.WithCN(3)), 0x45, 0x67, 0x89, 0xAB }, /* uint64 */ []byte { byte(LI.WithCN(7)), 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01, 0x23 }, + /* bool */ []byte { byte(SI.WithCN(0)) }, + /* bool */ []byte { byte(SI.WithCN(1)) }, /* string */ []byte { byte(SBA.WithCN(7)), 'p', 'u', 'p', 'e', 'v', 'e', 'r' }, /* []byte */ []byte { byte(SBA.WithCN(5)), 'b', 'l', 'a', 'r', 'g' }, /* []string */ []byte { @@ -45,6 +47,8 @@ var sampleValues = []any { /* uint16 */ uint16(0x4567), /* uint32 */ uint32(0x456789AB), /* uint64 */ uint64(0x456789ABCDEF0123), + /* bool */ false, + /* bool */ true, /* string */ "pupever", /* []byte */ "blarg", /* []string */ []string { @@ -84,7 +88,9 @@ func TestEncodeAnyTable(test *testing.T) { 0x3456: userDefinedInteger(0x3921), 0x1F1F: float32(67.26), 0x0F0F: float64(5.3), - }, KTV.WithCN(0), tu.S(9).AddVar( + 0xAAAA: false, + 0xBBBB: true, + }, KTV.WithCN(0), tu.S(11).AddVar( []byte { 0xF3, 0xB9, byte(LSI.WithCN(3)), @@ -138,6 +144,14 @@ func TestEncodeAnyTable(test *testing.T) { byte(FP.WithCN(7)), 0x40, 0x15, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, }, + []byte { + 0xAA, 0xAA, + byte(SI.WithCN(0)), + }, + []byte { + 0xBB, 0xBB, + byte(SI.WithCN(1)), + }, )) if err != nil { test.Fatal(err) } } -- 2.50.1 From 8446ae61869dbddd9ad0eab721f1b88d8df168c5 Mon Sep 17 00:00:00 2001 From: Sasha Koshka Date: Wed, 15 Oct 2025 01:07:51 -0400 Subject: [PATCH 09/10] tape: Implement bools in dymanic system --- tape/dynamic.go | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/tape/dynamic.go b/tape/dynamic.go index 7ce7665..763d5db 100644 --- a/tape/dynamic.go +++ b/tape/dynamic.go @@ -59,6 +59,7 @@ func EncodeAny(encoder *Encoder, value any, tag Tag) (n int, err error) { case reflect.Uint64: return encoder.WriteUint64(uint64(reflectValue.Uint())) case reflect.Float32: return encoder.WriteFloat32(float32(reflectValue.Float())) case reflect.Float64: return encoder.WriteFloat64(float64(reflectValue.Float())) + case reflect.Bool: return // SI has no payload case reflect.String: if reflectValue.Len() > MaxStructureLength { return 0, ErrTooLong @@ -298,6 +299,12 @@ func tagAny(reflectValue reflect.Value) (Tag, error) { case reflect.Uint64: return LI.WithCN(7), nil case reflect.Float32: return FP.WithCN(3), nil case reflect.Float64: return FP.WithCN(7), nil + case reflect.Bool: + if reflectValue.Bool() { + return SI.WithCN(1), nil + } else { + return SI.WithCN(0), nil + } case reflect.String: return bufferLenTag(reflectValue.Len()), nil } if reflectValue.CanConvert(reflect.TypeOf(dummyBuffer)) { @@ -374,7 +381,8 @@ func canSet(destination reflect.Type, tag Tag) error { switch destination.Kind() { case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, - reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: + reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, + reflect.Bool: default: return errCantAssignf("cannot assign integer to %v", destination) } -- 2.50.1 From 0ac26711acf00789c137936e4cf0b7c2a6f1fed9 Mon Sep 17 00:00:00 2001 From: Sasha Koshka Date: Wed, 15 Oct 2025 01:16:03 -0400 Subject: [PATCH 10/10] tape: Fix crash when decoding a bool sometimes --- tape/dynamic.go | 2 ++ tape/dynamic_test.go | 24 +++++++++++++++++++----- 2 files changed, 21 insertions(+), 5 deletions(-) diff --git a/tape/dynamic.go b/tape/dynamic.go index 763d5db..1c80fa0 100644 --- a/tape/dynamic.go +++ b/tape/dynamic.go @@ -440,6 +440,8 @@ func setInt(destination reflect.Value, value int64, bytes int) { // setUint expects a settable destination. func setUint(destination reflect.Value, value uint64, bytes int) { switch { + case destination.Kind() == reflect.Bool: + destination.Set(reflect.ValueOf(value > 0)) case destination.CanInt(): destination.Set(reflect.ValueOf(int64(value)).Convert(destination.Type())) case destination.CanUint(): diff --git a/tape/dynamic_test.go b/tape/dynamic_test.go index 969183f..7aa301c 100644 --- a/tape/dynamic_test.go +++ b/tape/dynamic_test.go @@ -160,7 +160,7 @@ func TestDecodeWrongType(test *testing.T) { for index, data := range samplePayloads { test.Logf("data %2d %v [%s]", index, Tag(data[0]), tu.HexBytes(data[1:])) // integers should only assign to other integers - if index > 8 { + if index > 10 { cas := func(destination any) { n, err := DecodeAnyInto(NewDecoder(bytes.NewBuffer(data[1:])), destination, Tag(data[0])) if err != nil { test.Fatalf("error: %v | n: %d", err, n) } @@ -169,7 +169,7 @@ func TestDecodeWrongType(test *testing.T) { if reflectValue.Int() != 0 { test.Fatalf("destination not zero: %v", reflectValue.Elem().Interface()) } - } else { + } else if reflectValue.Kind() != reflect.Bool { if reflectValue.Uint() != 0 { test.Fatalf("destination not zero: %v", reflectValue.Elem().Interface()) } @@ -194,6 +194,8 @@ func TestDecodeWrongType(test *testing.T) { { var dest uint32; cas(&dest) } test.Log("- uint64") { var dest uint64; cas(&dest) } + test.Log("- bool") + { var dest bool; cas(&dest) } } arrayCase := func(destination any) { n, err := DecodeAnyInto(NewDecoder(bytes.NewBuffer(data[1:])), destination, Tag(data[0])) @@ -208,19 +210,19 @@ func TestDecodeWrongType(test *testing.T) { } } // SBA/LBA types should only assign to other SBA/LBA types - if index != 9 && index != 10 { + if index != 11 && index != 12 { test.Log("- string") { var dest string; arrayCase(&dest) } test.Log("- []byte") { var dest []byte; arrayCase(&dest) } } // arrays should only assign to other arrays - if index != 11 { + if index != 13 { test.Log("- []string") { var dest []string; arrayCase(&dest) } } // tables should only assign to other tables - if index != 12 && index != 13 { + if index != 14 && index != 15 { test.Log("- map[uint16] any") { var dest = map[uint16] any { }; arrayCase(&dest) } } @@ -245,6 +247,12 @@ func TestEncodeDecodeAnyTable(test *testing.T) { func TestEncodeDecodeAnyDestination(test *testing.T) { var destination any for index, data := range samplePayloads { + if _, isBool := sampleValues[index].(bool); isBool { + // test is invalid for bools because they are never + // created as a skeleton value + continue + } + tag := Tag(data[0]) payload := data[1:] test.Logf("data %2d %v [%s]", index, tag, tu.HexBytes(payload)) @@ -363,6 +371,12 @@ func TestTagAny(test *testing.T) { func TestDecodeAny(test *testing.T) { for index, payload := range samplePayloads { + if _, isBool := sampleValues[index].(bool); isBool { + // test is invalid for bools because they are never + // created as a skeleton value + continue + } + correctValue := sampleValues[index] data := payload[1:] decoder := NewDecoder(bytes.NewBuffer(data)) -- 2.50.1