PUBKEY-CM.pub.asc | 10 +++++----- c/cmd/test-vector/test-vector.c | 2 +- c/lib/atom.h | 34 +++++++++++++++++----------------- go/atomtype_string.go | 89 +++++++++++++++++++++++------------------------------ go/blob_test.go | 21 +++++++++++++-------- go/bool_test.go | 4 ++-- go/cmd/convert-from-old-format/main.go | 110 +++++++++++++++++++++++++++++++++++++++++++++++++++++ go/float_test.go | 16 ++++++++-------- go/generic_test.go | 2 +- go/int_test.go | 32 ++++++++++++++++---------------- go/list_test.go | 2 +- go/map_test.go | 20 ++++++++++---------- go/tai_test.go | 42 +++++++++++++++++++++--------------------- go/type.go | 34 +++++++++++++++++----------------- py3/keks.py | 34 +++++++++++++++++----------------- py3/tests/test_blob.py | 24 +++++++++++++++--------- py3/tests/test_bool.py | 8 ++++---- py3/tests/test_float.py | 16 ++++++++-------- py3/tests/test_generic.py | 4 ++-- py3/tests/test_int.py | 26 +++++++++++++------------- py3/tests/test_list.py | 4 ++-- py3/tests/test_map.py | 33 +++++++++++++++++---------------- py3/tests/test_tai.py | 64 +++++++++++++++++++++++++++--------------------------- spec/encoding/BLOB | 10 +++++----- spec/encoding/FLOAT | 26 +++++++++++++------------- spec/encoding/FullTable | 257 ----------------------------------------------------- spec/encoding/INT | 28 ++++++++++++++-------------- spec/encoding/LIST | 4 ++-- spec/encoding/MAGIC | 4 ++-- spec/encoding/MAP | 4 ++-- spec/encoding/PRIM | 6 +++--- spec/encoding/TAI | 20 ++++++++++---------- spec/encoding/index | 74 ++++++++++++++++++++++++++--------------------------- tcl/keks.tcl | 39 +++++++++++++++++---------------------- tcl/mk-fuzz-inputs | 6 ++++-- diff --git a/PUBKEY-CM.pub b/PUBKEY-CM.pub index b7f90807964693674f9012b00a62fbbb883141b498d0ad0ff0a6643f622c4825..fecc243617802bf91f3c78189bedcd2f474ec9fcbb6ecda3bf26c1151fe3469d 100644 Binary files a/PUBKEY-CM.pub and b/PUBKEY-CM.pub differ diff --git a/PUBKEY-CM.pub.asc b/PUBKEY-CM.pub.asc index fac141363803037482ae308a2ae8bc593a7aa74c00cbea25a99bf06f3095a428..e978dd62e8f87bdcfa308fbd31f1b2dcbc4a9bf227f3c7ab4a9f7552d54c6795 100644 --- a/PUBKEY-CM.pub.asc +++ b/PUBKEY-CM.pub.asc @@ -1,8 +1,8 @@ -----BEGIN PGP SIGNATURE----- -iJEEABYKADkWIQTbL/jtRAp+lJhvt3bSI36ECQhstwUCahLJxxsUgAAAAAAEAA5t -YW51MiwyLjUrMS4xMiwyLDMACgkQ0iN+hAkIbLcDbQD9HrUzgMmJ6DmMpLyh/EiV -zsqTs4cxEQ7BhM8PGb6sP5QA/2m5ZnDzRn84yDsMc0PXBmDKINegObtaYuvBndK9 -ym8I -=hncb +iJEEABYKADkWIQTbL/jtRAp+lJhvt3bSI36ECQhstwUCajlT0RsUgAAAAAAEAA5t +YW51MiwyLjUrMS4xMiwyLDMACgkQ0iN+hAkIbLfSoQEAz1p+UUWq5E/SHwrhb9jA +B1jlX3oh7CbVw/8/mAdUXdQA/0+i1RFGStUxwjpshGPDHZOvvrzimZpUDv2bv0nW +kWUG +=68M6 -----END PGP SIGNATURE----- diff --git a/c/cmd/test-vector/test-vector.c b/c/cmd/test-vector/test-vector.c index a7da11b6bae2555728d2ca7cd2693355264ce95843de5355918ce7bfa05c328d..1c5586eb95e5b25a2dc2c49160d46291ae06f880001b3060c04ebdce6548ddf8 100644 --- a/c/cmd/test-vector/test-vector.c +++ b/c/cmd/test-vector/test-vector.c @@ -262,7 +262,7 @@ size_t l = 18; memcpy( buf + Off, (const unsigned char - *)"\x0C\x8C\x27\xE4\x1B\x32\x46\xBE\xC9\xB1\x6E\x39\x81\x15\x0D\x82\x30\x38", + *)"\x2B\x8C\x27\xE4\x1B\x32\x46\xBE\xC9\xB1\x6E\x39\x81\x15\x2D\x82\x30\x38", l); Off += l; } diff --git a/c/lib/atom.h b/c/lib/atom.h index a06dee7b4cee55bcab2e2699482332d6e9117b595bdf030a63219f89bcd1a1f7..bd5419fe94717bab9d1f0084e5d8c7d434390fd96914665260c63aa83a872107 100644 --- a/c/lib/atom.h +++ b/c/lib/atom.h @@ -6,23 +6,23 @@ #include #include enum KEKSAtomType { - KEKSAtomEOC = 0x00, - KEKSAtomNIL = 0x01, - KEKSAtomFalse = 0x02, - KEKSAtomTrue = 0x03, - KEKSAtomList = 0x08, - KEKSAtomMap = 0x09, - KEKSAtomBlob = 0x0B, - KEKSAtomPint = 0x0C, - KEKSAtomNint = 0x0D, - KEKSAtomFloatNaN = 0x10, - KEKSAtomFloatPinf = 0x11, - KEKSAtomFloatNinf = 0x12, - KEKSAtomFloat = 0x13, - KEKSAtomTAI64 = 0x18, - KEKSAtomTAI64N = 0x19, - KEKSAtomTAI64NA = 0x1A, - KEKSAtomMagic = 0x4B, + KEKSAtomEOC = '.', + KEKSAtomNIL = '!', + KEKSAtomFalse = 'f', + KEKSAtomTrue = 't', + KEKSAtomList = 'L', + KEKSAtomMap = 'M', + KEKSAtomBlob = 'B', + KEKSAtomPint = '+', + KEKSAtomNint = '-', + KEKSAtomFloatNaN = '_', + KEKSAtomFloatPinf = '>', + KEKSAtomFloatNinf = '<', + KEKSAtomFloat = '~', + KEKSAtomTAI64 = 'T', + KEKSAtomTAI64N = 'N', + KEKSAtomTAI64NA = 'A', + KEKSAtomMagic = 'K', KEKSAtomStrings = 0x80, KEKSAtomIsUTF8 = 0x40, diff --git a/go/atomtype_string.go b/go/atomtype_string.go index 319a3ea2c0142947911e9859c315492b07881834f31df4d6da93ddb96a6c3109..405dbb355a21bde7319b75851e8c7b4ac6d45ed61dfdb0258c38447e003fcc72 100644 --- a/go/atomtype_string.go +++ b/go/atomtype_string.go @@ -8,61 +8,50 @@ func _() { // An "invalid array index" compiler error signifies that the constant values have changed. // Re-run the stringer command to generate them again. var x [1]struct{} - _ = x[AtomEOC-0] - _ = x[AtomNIL-1] - _ = x[AtomFalse-2] - _ = x[AtomTrue-3] - _ = x[AtomList-8] - _ = x[AtomMap-9] - _ = x[AtomBLOB-11] - _ = x[AtomPInt-12] - _ = x[AtomNInt-13] - _ = x[AtomFloatNaN-16] - _ = x[AtomFloatPinf-17] - _ = x[AtomFloatNinf-18] - _ = x[AtomFloat-19] - _ = x[AtomTAI64-24] - _ = x[AtomTAI64N-25] - _ = x[AtomTAI64NA-26] + _ = x[AtomEOC-46] + _ = x[AtomNIL-33] + _ = x[AtomFalse-102] + _ = x[AtomTrue-116] + _ = x[AtomList-76] + _ = x[AtomMap-77] + _ = x[AtomBLOB-66] + _ = x[AtomPInt-43] + _ = x[AtomNInt-45] + _ = x[AtomFloatNaN-95] + _ = x[AtomFloatPinf-62] + _ = x[AtomFloatNinf-60] + _ = x[AtomFloat-126] + _ = x[AtomTAI64-84] + _ = x[AtomTAI64N-78] + _ = x[AtomTAI64NA-65] _ = x[AtomMagic-75] } -const ( - _AtomType_name_0 = "AtomEOCAtomNILAtomFalseAtomTrue" - _AtomType_name_1 = "AtomListAtomMap" - _AtomType_name_2 = "AtomBLOBAtomPIntAtomNInt" - _AtomType_name_3 = "AtomFloatNaNAtomFloatPinfAtomFloatNinfAtomFloat" - _AtomType_name_4 = "AtomTAI64AtomTAI64NAtomTAI64NA" - _AtomType_name_5 = "AtomMagic" -) +const _AtomType_name = "AtomNILAtomPIntAtomNIntAtomEOCAtomFloatNinfAtomFloatPinfAtomTAI64NAAtomBLOBAtomMagicAtomListAtomMapAtomTAI64NAtomTAI64AtomFloatNaNAtomFalseAtomTrueAtomFloat" -var ( - _AtomType_index_0 = [...]uint8{0, 7, 14, 23, 31} - _AtomType_index_1 = [...]uint8{0, 8, 15} - _AtomType_index_2 = [...]uint8{0, 8, 16, 24} - _AtomType_index_3 = [...]uint8{0, 12, 25, 38, 47} - _AtomType_index_4 = [...]uint8{0, 9, 19, 30} -) +var _AtomType_map = map[AtomType]string{ + 33: _AtomType_name[0:7], + 43: _AtomType_name[7:15], + 45: _AtomType_name[15:23], + 46: _AtomType_name[23:30], + 60: _AtomType_name[30:43], + 62: _AtomType_name[43:56], + 65: _AtomType_name[56:67], + 66: _AtomType_name[67:75], + 75: _AtomType_name[75:84], + 76: _AtomType_name[84:92], + 77: _AtomType_name[92:99], + 78: _AtomType_name[99:109], + 84: _AtomType_name[109:118], + 95: _AtomType_name[118:130], + 102: _AtomType_name[130:139], + 116: _AtomType_name[139:147], + 126: _AtomType_name[147:156], +} func (i AtomType) String() string { - switch { - case i <= 3: - return _AtomType_name_0[_AtomType_index_0[i]:_AtomType_index_0[i+1]] - case 8 <= i && i <= 9: - i -= 8 - return _AtomType_name_1[_AtomType_index_1[i]:_AtomType_index_1[i+1]] - case 11 <= i && i <= 13: - i -= 11 - return _AtomType_name_2[_AtomType_index_2[i]:_AtomType_index_2[i+1]] - case 16 <= i && i <= 19: - i -= 16 - return _AtomType_name_3[_AtomType_index_3[i]:_AtomType_index_3[i+1]] - case 24 <= i && i <= 26: - i -= 24 - return _AtomType_name_4[_AtomType_index_4[i]:_AtomType_index_4[i+1]] - case i == 75: - return _AtomType_name_5 - default: - return "AtomType(" + strconv.FormatInt(int64(i), 10) + ")" + if str, ok := _AtomType_map[i]; ok { + return str } + return "AtomType(" + strconv.FormatInt(int64(i), 10) + ")" } diff --git a/go/blob_test.go b/go/blob_test.go index 08f24a83f5932907fb87ae3f30a7013b64fde64a74cd1136b38e5f6c4b52fb8f..a83ecd85508f532f141e88bcf1b434cb71ec813d6eab7b52cbc5ce266dcc75e7 100644 --- a/go/blob_test.go +++ b/go/blob_test.go @@ -26,7 +26,8 @@ ) func TestBlobMultipleOfChunkLen(t *testing.T) { bin := bytes.Join([][]byte{ - mustHexDec("0B0C8103"), + {'B'}, + mustHexDec("2B8103"), {0x84}, []byte("test"), {0x84}, @@ -82,7 +83,8 @@ } func TestBlobLargerOfChunkLen(t *testing.T) { bin := bytes.Join([][]byte{ - mustHexDec("0B0C8103"), + {'B'}, + mustHexDec("2B8103"), {0x84}, []byte("test"), {0x84}, @@ -141,7 +143,7 @@ } } func TestBlobEmpty(t *testing.T) { - bin := mustHexDec("0B0C8103" + "80") + bin := mustHexDec("422B8103" + "80") encoded, err := EncodeBuf(BlobReader{ ChunkLen: 4, R: bytes.NewReader(nil), @@ -240,7 +242,8 @@ } func TestBlobNotEnoughData(t *testing.T) { bin := bytes.Join([][]byte{ - mustHexDec("0B0C8103"), + {'B'}, + mustHexDec("2B8103"), {0x84}, []byte("test"), {0x84}, @@ -263,7 +266,7 @@ } } func TestBlobNotEnoughDataForLength(t *testing.T) { - bin := mustHexDec("0B0C81") + bin := mustHexDec("422B81") _, err := NewDecoderFromBytes(bin, nil).Decode() if err != io.ErrUnexpectedEOF { t.Fatal(err) @@ -272,7 +275,8 @@ } func TestBlobWrongTerminatorLength(t *testing.T) { bin := bytes.Join([][]byte{ - mustHexDec("0B0C8103"), + {'B'}, + mustHexDec("2B8103"), {0x84}, []byte("test"), {0x84}, @@ -288,12 +292,13 @@ } func TestBlobWrongTerminatorTag(t *testing.T) { bin := bytes.Join([][]byte{ - mustHexDec("0B0C8103"), + {'B'}, + mustHexDec("2B8103"), {0x84}, []byte("test"), {0x84}, []byte("data"), - {0x04}, + {'!'}, []byte("that was a wrong tag"), }, nil) _, err := NewDecoderFromBytes(bin, nil).Decode() diff --git a/go/bool_test.go b/go/bool_test.go index db7b4203ecf20a3981861af450470a959a070bfa0ff4539de94f5ecfb6a2f539..5d51a305fb7617547ddbe623340ee475837a332c225f839061913f3f3977f46d 100644 --- a/go/bool_test.go +++ b/go/bool_test.go @@ -22,7 +22,7 @@ "testing" ) func TestBoolTrue(t *testing.T) { - bin := mustHexDec("03") + bin := []byte{'t'} decoder := NewDecoderFromBytes(append(bin, Junk...), nil) decoded, err := decoder.Decode() if err != nil { @@ -48,7 +48,7 @@ } } func TestBoolFalse(t *testing.T) { - bin := mustHexDec("02") + bin := []byte{'f'} decoder := NewDecoderFromBytes(append(bin, Junk...), nil) decoded, err := decoder.Decode() if err != nil { diff --git a/go/cmd/convert-from-old-format/main.go b/go/cmd/convert-from-old-format/main.go new file mode 100644 index 0000000000000000000000000000000000000000..780e18fe5b409beda4bcc453c7b1bfa9018c789c76f7b2bb6c34dec9b4b13c3f --- /dev/null +++ b/go/cmd/convert-from-old-format/main.go @@ -0,0 +1,110 @@ +package main + +import ( + "bufio" + "bytes" + "errors" + "io" + "os" + + "go.stargrave.org/keks/be" +) + +func mustCopy(w io.Writer, r io.Reader, n int64) { + if _, err := io.CopyN(w, r, n); err != nil { + panic(err) + } +} + +var UnknownTag = errors.New("unknown tag") + +func main() { + br := bufio.NewReader(os.Stdin) + bw := bufio.NewWriter(os.Stdout) + var b byte + var err error + var l, ll int64 + var buf bytes.Buffer + for { + b, err = br.ReadByte() + if err != nil { + if err == io.EOF { + break + } + panic(err) + } + switch b { + case 0x00: + bw.WriteByte('.') + case 0x01: + bw.WriteByte('!') + case 0x02: + bw.WriteByte('f') + case 0x03: + bw.WriteByte('t') + case 0x08: + bw.WriteByte('L') + case 0x09: + bw.WriteByte('M') + case 0x0B: + bw.WriteByte('B') + case 0x0C: + bw.WriteByte('+') + case 0x0D: + bw.WriteByte('-') + case 0x10: + bw.WriteByte('_') + case 0x11: + bw.WriteByte('>') + case 0x12: + bw.WriteByte('<') + case 0x13: + bw.WriteByte('~') + case 0x18: + bw.WriteByte('T') + mustCopy(bw, br, 8) + case 0x19: + bw.WriteByte('N') + mustCopy(bw, br, 8+4) + case 0x1A: + bw.WriteByte('A') + mustCopy(bw, br, 8+4+4) + case 0x4B: + bw.WriteByte('K') + mustCopy(bw, br, 16-1) + default: + err = UnknownTag + } + if err == nil { + continue + } + if b&0x80 == 0 { + panic("this is not a str") + } + bw.WriteByte(b) + l = int64(b & 63) + ll = 0 + switch l { + case 61: + ll = 1 + case 62: + ll = 2 + l += ((1 << 8) - 1) + case 63: + ll = 8 + l += ((1 << 8) - 1) + ((1 << 16) - 1) + } + if ll != 0 { + buf.Reset() + mustCopy(&buf, br, ll) + ul := be.Get(buf.Bytes()) + if ul > (1<<63)-(63+((1<<8)-1)+((1<<16)-1)) { + panic("too big") + } + l += int64(ul) + mustCopy(bw, &buf, ll) + } + mustCopy(bw, br, l) + } + bw.Flush() +} diff --git a/go/float_test.go b/go/float_test.go index 95ee07c2d49f07662e8566f624a11b2df25ab3740db71110d2d7eab55138d5f6..df255619adc7ac7b7209300fceecd18ce9b58ce6efd9f526387fa701ce6e7e9f 100644 --- a/go/float_test.go +++ b/go/float_test.go @@ -31,7 +31,7 @@ } } func TestFloatNaN(t *testing.T) { - bin := []byte{0x10} + bin := []byte{'_'} decoder := NewDecoderFromBytes(append(bin, Junk...), nil) decoded, err := decoder.Decode() if err != nil { @@ -53,7 +53,7 @@ } } func TestFloatPinf(t *testing.T) { - bin := []byte{0x11} + bin := []byte{'>'} decoder := NewDecoderFromBytes(append(bin, Junk...), nil) decoded, err := decoder.Decode() if err != nil { @@ -75,7 +75,7 @@ } } func TestFloatNinf(t *testing.T) { - bin := []byte{0x12} + bin := []byte{'<'} decoder := NewDecoderFromBytes(append(bin, Junk...), nil) decoded, err := decoder.Decode() if err != nil { @@ -98,7 +98,7 @@ } func TestFloat0(t *testing.T) { var b bytes.Buffer - b.Write([]byte{0x13}) + b.Write([]byte{'~'}) UIntEncode(&b, 0) UIntEncode(&b, 0) b.Write(Junk) @@ -130,7 +130,7 @@ } } func TestFloatNotEnough(t *testing.T) { - decoder := NewDecoderFromBytes([]byte{0x13}, nil) + decoder := NewDecoderFromBytes([]byte{'~'}, nil) _, err := decoder.Decode() if err != io.ErrUnexpectedEOF { t.Fatal(err) @@ -139,7 +139,7 @@ } func TestFloatSingleInt(t *testing.T) { var b bytes.Buffer - b.Write([]byte{0x13}) + b.Write([]byte{'~'}) UIntEncode(&b, 0) decoder := NewDecoderFromBytes(b.Bytes(), nil) _, err := decoder.Decode() @@ -150,7 +150,7 @@ } func TestFloatNonInt0(t *testing.T) { var b bytes.Buffer - b.Write([]byte{0x13}) + b.Write([]byte{'~'}) BoolEncode(&b, true) decoder := NewDecoderFromBytes(b.Bytes(), nil) _, err := decoder.Decode() @@ -161,7 +161,7 @@ } func TestFloatNonInt1(t *testing.T) { var b bytes.Buffer - b.Write([]byte{0x13}) + b.Write([]byte{'~'}) UIntEncode(&b, 0) BoolEncode(&b, true) decoder := NewDecoderFromBytes(b.Bytes(), nil) diff --git a/go/generic_test.go b/go/generic_test.go index 42e4f0690e4d5da3634aa327887d0002c75f1b122f8fbbe15ce2501f7d42109f..1d63687f3e0e476d0b2e4caac04711972c91906d51f9998bf952c0e27a6d3aa1 100644 --- a/go/generic_test.go +++ b/go/generic_test.go @@ -37,7 +37,7 @@ } } func TestLonelyEOC(t *testing.T) { - _, err := NewDecoderFromBytes(append([]byte{0x00}, Junk...), nil).Decode() + _, err := NewDecoderFromBytes(append([]byte{'.'}, Junk...), nil).Decode() if err != ErrEOCUnexpected { t.Fatal(err) } diff --git a/go/int_test.go b/go/int_test.go index 6fb70735fb76281041871f6800456935899a05498869ead0661798545364e8f0..0aab7ecc24c9b4ab72690bbf0e0ad35352f57070905ef2e1d16d52436c87217e 100644 --- a/go/int_test.go +++ b/go/int_test.go @@ -26,7 +26,7 @@ ) func TestInt0(t *testing.T) { obj := int(0) - bin := mustHexDec("0C80") + bin := mustHexDec("2B80") decoder := NewDecoderFromBytes(append(bin, Junk...), nil) decoded, err := decoder.Decode() if err != nil { @@ -53,7 +53,7 @@ } func TestInt1(t *testing.T) { obj := int(1) - bin := mustHexDec("0C8101") + bin := mustHexDec("2B8101") decoder := NewDecoderFromBytes(append(bin, Junk...), nil) decoded, err := decoder.Decode() if err != nil { @@ -80,7 +80,7 @@ } func TestIntM1(t *testing.T) { obj := int(-1) - bin := mustHexDec("0D80") + bin := mustHexDec("2D80") decoder := NewDecoderFromBytes(append(bin, Junk...), nil) decoded, err := decoder.Decode() if err != nil { @@ -107,7 +107,7 @@ } func TestInt123(t *testing.T) { obj := uint(123) - bin := mustHexDec("0C817B") + bin := mustHexDec("2B817B") decoder := NewDecoderFromBytes(append(bin, Junk...), nil) decoded, err := decoder.Decode() if err != nil { @@ -134,7 +134,7 @@ } func TestIntM123(t *testing.T) { obj := int(-123) - bin := mustHexDec("0D817A") + bin := mustHexDec("2D817A") decoder := NewDecoderFromBytes(append(bin, Junk...), nil) decoded, err := decoder.Decode() if err != nil { @@ -161,7 +161,7 @@ } func TestIntMaxAllowable(t *testing.T) { obj := uint64(1<<63) - 1 - bin := mustHexDec("0C887FFFFFFFFFFFFFFF") + bin := mustHexDec("2B887FFFFFFFFFFFFFFF") decoder := NewDecoderFromBytes(append(bin, Junk...), nil) decoded, err := decoder.Decode() if err != nil { @@ -188,7 +188,7 @@ } func TestIntNMaxAllowable(t *testing.T) { obj := -int64(uint64(1<<63) - 1) - bin := mustHexDec("0D887FFFFFFFFFFFFFFE") + bin := mustHexDec("2D887FFFFFFFFFFFFFFE") decoder := NewDecoderFromBytes(append(bin, Junk...), nil) decoded, err := decoder.Decode() if err != nil { @@ -216,7 +216,7 @@ func TestInt64bit(t *testing.T) { obj := big.NewInt(0) obj = obj.SetBit(obj, 64, 1) - bin := mustHexDec("0C89010000000000000000") + bin := mustHexDec("2B89010000000000000000") decoder := NewDecoderFromBytes(append(bin, Junk...), nil) decoded, err := decoder.Decode() if err != nil { @@ -245,7 +245,7 @@ func TestIntM64bit(t *testing.T) { obj := big.NewInt(0) obj = obj.SetBit(obj, 64, 1) obj = obj.Neg(obj) - bin := mustHexDec("0D88FFFFFFFFFFFFFFFF") + bin := mustHexDec("2D88FFFFFFFFFFFFFFFF") decoder := NewDecoderFromBytes(append(bin, Junk...), nil) decoded, err := decoder.Decode() if err != nil { @@ -275,7 +275,7 @@ obj := big.NewInt(0) obj = obj.SetBit(obj, 64, 1) obj = obj.SetBit(obj, 0, 1) obj = obj.Neg(obj) - bin := mustHexDec("0D89010000000000000000") + bin := mustHexDec("2D89010000000000000000") decoder := NewDecoderFromBytes(append(bin, Junk...), nil) decoded, err := decoder.Decode() if err != nil { @@ -303,7 +303,7 @@ func TestInt131bit(t *testing.T) { obj := big.NewInt(0) obj = obj.SetBit(obj, 130, 1) - bin := mustHexDec("0C910400000000000000000000000000000000") + bin := mustHexDec("2B910400000000000000000000000000000000") decoder := NewDecoderFromBytes(append(bin, Junk...), nil) decoded, err := decoder.Decode() if err != nil { @@ -332,7 +332,7 @@ func TestIntM131bit(t *testing.T) { obj := big.NewInt(0) obj = obj.SetBit(obj, 130, 1) obj = obj.Neg(obj) - bin := mustHexDec("0D9103FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF") + bin := mustHexDec("2D9103FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF") decoder := NewDecoderFromBytes(append(bin, Junk...), nil) decoded, err := decoder.Decode() if err != nil { @@ -358,18 +358,18 @@ } } func TestIntNotEnoughData(t *testing.T) { - _, err := NewDecoderFromBytes(mustHexDec("0C830102"), nil).Decode() + _, err := NewDecoderFromBytes(mustHexDec("2B830102"), nil).Decode() if err != io.ErrUnexpectedEOF { t.Fatal(err) } - _, err = NewDecoderFromBytes(mustHexDec("0C8301"), nil).Decode() + _, err = NewDecoderFromBytes(mustHexDec("2B8301"), nil).Decode() if err != io.ErrUnexpectedEOF { t.Fatal(err) } } func TestIntNonMinimalInt(t *testing.T) { - encoded := mustHexDec("0C81007B") + encoded := mustHexDec("2B81007B") _, err := NewDecoderFromBytes(encoded, nil).Decode() if err != ErrIntNonMinimal { t.Fatal(err) @@ -377,7 +377,7 @@ } } func TestIntNonBinInInt(t *testing.T) { - encoded := mustHexDec("0C017B") + encoded := mustHexDec("2B017B") _, err := NewDecoderFromBytes(encoded, nil).Decode() if err != ErrIntBad { t.Fatal(err) diff --git a/go/list_test.go b/go/list_test.go index a3a493e97f04aeeb2928fe22c5a64dfd84812648af42e70c3f197c6d5f36f04b..4032b24a8494bde63ccdef0d03f194753c314b1ee3dbaacf7c39c1b777cd2077 100644 --- a/go/list_test.go +++ b/go/list_test.go @@ -27,7 +27,7 @@ ) func TestListEmpty(t *testing.T) { obj := []any{} - bin := []byte{0x08, 0x00} + bin := []byte{'L', '.'} decoder := NewDecoderFromBytes(append(bin, Junk...), nil) decoded, err := decoder.Decode() if err != nil { diff --git a/go/map_test.go b/go/map_test.go index 93c98eadaf4718741435f5f1b997802bf768703f0cfa97874ecdd5d9627b0a1e..52f5266ddb3602fbfeaf3b803e3e4c5d9f34bb5618035741f225b25b2d4004ea 100644 --- a/go/map_test.go +++ b/go/map_test.go @@ -25,7 +25,7 @@ "testing/quick" ) func TestMapEmpty(t *testing.T) { - bin := []byte("\x09\x00") + bin := []byte{'M', '.'} decoder := NewDecoderFromBytes(append(bin, Junk...), nil) decoded, err := decoder.Decode() if err != nil { @@ -58,14 +58,14 @@ } } func TestMapDecodeNonStrKey(t *testing.T) { - _, err := NewDecoderFromBytes([]byte("\x09\x0C\x80\xC6value2\x00"), nil).Decode() + _, err := NewDecoderFromBytes([]byte("\x4D\x2B\x80\xC6value2\x2E"), nil).Decode() if err != ErrMapBadKey { t.Fatal(err) } } func TestMapUnexpectedEOC(t *testing.T) { - _, err := NewDecoderFromBytes([]byte("\x09\xC4key1\x00\x00"), nil).Decode() + _, err := NewDecoderFromBytes([]byte("\x4D\xC4key1\x2E\x2E"), nil).Decode() if err != ErrEOCUnexpected { t.Fatal(err) } @@ -79,7 +79,7 @@ } } func TestMapDecodeEmptyStrKey(t *testing.T) { - _, err := NewDecoderFromBytes(mustHexDec("09C0C000"), nil).Decode() + _, err := NewDecoderFromBytes(mustHexDec("4DC0C02E"), nil).Decode() if err != ErrMapBadKey { t.Fatal(err) } @@ -87,12 +87,12 @@ } func TestMapUnsortedValueKeys(t *testing.T) { bin := bytes.Join([][]byte{ - mustHexDec("09"), + {'M'}, mustHexDec("C4"), []byte("key2"), - mustHexDec("0C8101"), + mustHexDec("2B8101"), mustHexDec("C4"), []byte("key1"), mustHexDec("C6"), []byte("value1"), - mustHexDec("00"), + {'.'}, }, nil) _, err := NewDecoderFromBytes(bin, nil).Decode() if err != ErrMapUnordered { @@ -102,12 +102,12 @@ } func TestMapUnsortedLenKeys(t *testing.T) { bin := bytes.Join([][]byte{ - mustHexDec("09"), + {'M'}, mustHexDec("C4"), []byte("key2"), - mustHexDec("0C8101"), + mustHexDec("2B8101"), mustHexDec("C3"), []byte("key"), mustHexDec("C6"), []byte("value1"), - mustHexDec("00"), + {'.'}, }, nil) _, err := NewDecoderFromBytes(bin, nil).Decode() if err != ErrMapUnordered { diff --git a/go/tai_test.go b/go/tai_test.go index 4be7d1fcb7e6c9b9a5b6cb282edaec6ee8e8a2d940253102e45810f4894efd89..94540039628510035b1351497ba6c3731d63aa00dabf7aeee730e546269608db 100644 --- a/go/tai_test.go +++ b/go/tai_test.go @@ -32,7 +32,7 @@ const hex1G = "3B9ACA00" // one billion func TestTAINotEnoughData(t *testing.T) { _, err := NewDecoderFromBytes(mustHexDec( - "18"+strings.Repeat("0", 2*8-2)), nil).Decode() + "54"+strings.Repeat("0", 2*8-2)), nil).Decode() if err != io.ErrUnexpectedEOF { t.Fatal(err) } @@ -40,7 +40,7 @@ } func TestTAINNotEnoughData(t *testing.T) { _, err := NewDecoderFromBytes(mustHexDec( - "19"+strings.Repeat("0", 2*12-2)), nil).Decode() + "4E"+strings.Repeat("0", 2*12-2)), nil).Decode() if err != io.ErrUnexpectedEOF { t.Fatal(err) } @@ -48,7 +48,7 @@ } func TestTAINANotEnoughData(t *testing.T) { _, err := NewDecoderFromBytes(mustHexDec( - "1A"+strings.Repeat("0", 2*16-2)), nil).Decode() + "41"+strings.Repeat("0", 2*16-2)), nil).Decode() if err != io.ErrUnexpectedEOF { t.Fatal(err) } @@ -56,7 +56,7 @@ } func TestTAILargeNumberOfSeconds(t *testing.T) { _, err := NewDecoderFromBytes(mustHexDec( - "18"+"7000000065195F65"), nil).Decode() + "54"+"7000000065195F65"), nil).Decode() if err != nil { t.Fatal(err) } @@ -64,7 +64,7 @@ } func TestTAINLargeNumberOfSeconds(t *testing.T) { _, err := NewDecoderFromBytes(mustHexDec( - "19"+"7000000065195F65"+"00010000"), nil).Decode() + "4E"+"7000000065195F65"+"00010000"), nil).Decode() if err != nil { t.Fatal(err) } @@ -72,7 +72,7 @@ } func TestTAINALargeNumberOfSeconds(t *testing.T) { _, err := NewDecoderFromBytes(mustHexDec( - "1A"+"7000000065195F65"+"00010000"+"00010000"), nil).Decode() + "41"+"7000000065195F65"+"00010000"+"00010000"), nil).Decode() if err != nil { t.Fatal(err) } @@ -80,7 +80,7 @@ } func TestTAIMsbIsSet(t *testing.T) { _, err := NewDecoderFromBytes(mustHexDec( - "18"+"8000000065195F65"), nil).Decode() + "54"+"8000000065195F65"), nil).Decode() if err != ErrTAIReserved { t.Fatal(err) } @@ -88,7 +88,7 @@ } func TestTAINMsbIsSet(t *testing.T) { _, err := NewDecoderFromBytes(mustHexDec( - "19"+"8000000065195F65"+"00010000"), nil).Decode() + "4E"+"8000000065195F65"+"00010000"), nil).Decode() if err != ErrTAIReserved { t.Fatal(err) } @@ -96,14 +96,14 @@ } func TestTAINAMsbIsSet(t *testing.T) { _, err := NewDecoderFromBytes(mustHexDec( - "19"+"8000000065195F65"+"00010000"+"00010000"), nil).Decode() + "4E"+"8000000065195F65"+"00010000"+"00010000"), nil).Decode() if err != ErrTAIReserved { t.Fatal(err) } } func TestTAINTooManyNanosecs(t *testing.T) { - bin := mustHexDec("19" + "4000000000000000" + hex1G) + bin := mustHexDec("4E" + "4000000000000000" + hex1G) _, err := NewDecoderFromBytes(bin, nil).Decode() if err != ErrTAITooManyNsecs { t.Fatal(err) @@ -111,7 +111,7 @@ } } func TestTAINATooManyNanosecs(t *testing.T) { - bin := mustHexDec("1A" + "4000000000000000" + hex1G + "00010000") + bin := mustHexDec("41" + "4000000000000000" + hex1G + "00010000") _, err := NewDecoderFromBytes(bin, nil).Decode() if err != ErrTAITooManyNsecs { t.Fatal(err) @@ -119,7 +119,7 @@ } } func TestTAINATooManyAttosecs(t *testing.T) { - bin := mustHexDec("1A" + "4000000000000000" + "00010000" + hex1G) + bin := mustHexDec("41" + "4000000000000000" + "00010000" + hex1G) _, err := NewDecoderFromBytes(bin, nil).Decode() if err != ErrTAITooManyAsecs { t.Fatal(err) @@ -127,7 +127,7 @@ } } func TestTAINZeroNanosecs(t *testing.T) { - bin := mustHexDec("19" + "4000000000000000" + "00000000") + bin := mustHexDec("4E" + "4000000000000000" + "00000000") _, err := NewDecoderFromBytes(bin, nil).Decode() if err != ErrTAINonMinimal { t.Fatal(err) @@ -135,7 +135,7 @@ } } func TestTAINAZeroNanosecsOk(t *testing.T) { - bin := mustHexDec("1A" + "4000000000000000" + "00000000" + "00000001") + bin := mustHexDec("41" + "4000000000000000" + "00000000" + "00000001") _, err := NewDecoderFromBytes(bin, nil).Decode() if err != nil { t.Fatal(err) @@ -143,7 +143,7 @@ } } func TestTAINAZeroAttosecs(t *testing.T) { - bin := mustHexDec("1A" + "4000000000000000" + "00000000" + "00000000") + bin := mustHexDec("41" + "4000000000000000" + "00000000" + "00000000") _, err := NewDecoderFromBytes(bin, nil).Decode() if err != ErrTAINonMinimal { t.Fatal(err) @@ -152,7 +152,7 @@ } func TestTAI19700101(t *testing.T) { decoded, err := NewDecoderFromBytes(mustHexDec( - "18400000000000000A"), nil).Decode() + "54400000000000000A"), nil).Decode() if err != nil { t.Fatal(err) } @@ -167,7 +167,7 @@ } func TestTAI19920602(t *testing.T) { decoded, err := NewDecoderFromBytes(mustHexDec( - "18400000002A2B2C2D"), nil).Decode() + "54400000002A2B2C2D"), nil).Decode() if err != nil { t.Fatal(err) } @@ -182,7 +182,7 @@ } func TestTAI19971003(t *testing.T) { decoded, err := NewDecoderFromBytes(mustHexDec( - "184000000034353637"), nil).Decode() + "544000000034353637"), nil).Decode() if err != nil { t.Fatal(err) } @@ -197,7 +197,7 @@ } func TestTAI20161231(t *testing.T) { decoded, err := NewDecoderFromBytes(mustHexDec( - "1840000000586846A3"), nil).Decode() + "5440000000586846A3"), nil).Decode() if err != nil { t.Fatal(err) } @@ -212,7 +212,7 @@ } func TestTAI20170101(t *testing.T) { decoded, err := NewDecoderFromBytes(mustHexDec( - "1840000000586846A5"), nil).Decode() + "5440000000586846A5"), nil).Decode() if err != nil { t.Fatal(err) } @@ -227,7 +227,7 @@ } func TestTAI20241120(t *testing.T) { decoded, err := NewDecoderFromBytes(mustHexDec( - "1940000000673DD3E136F11FE0"), nil).Decode() + "4E40000000673DD3E136F11FE0"), nil).Decode() if err != nil { t.Fatal(err) } diff --git a/go/type.go b/go/type.go index 067a67c85d024c2a21bb60f1c2e5572193e6a24ba0765312402656350fe59ab1..6f99afd526b213bf4f47831d37cdf5979900db1e6edf487c1038a065fb84fb77 100644 --- a/go/type.go +++ b/go/type.go @@ -4,23 +4,23 @@ type AtomType byte //go:generate stringer -type=AtomType const ( - AtomEOC AtomType = 0x00 - AtomNIL AtomType = 0x01 - AtomFalse AtomType = 0x02 - AtomTrue AtomType = 0x03 - AtomList AtomType = 0x08 - AtomMap AtomType = 0x09 - AtomBLOB AtomType = 0x0B - AtomPInt AtomType = 0x0C - AtomNInt AtomType = 0x0D - AtomFloatNaN AtomType = 0x10 - AtomFloatPinf AtomType = 0x11 - AtomFloatNinf AtomType = 0x12 - AtomFloat AtomType = 0x13 - AtomTAI64 AtomType = 0x18 - AtomTAI64N AtomType = 0x19 - AtomTAI64NA AtomType = 0x1A - AtomMagic AtomType = 0x4B + AtomEOC AtomType = '.' + AtomNIL AtomType = '!' + AtomFalse AtomType = 'f' + AtomTrue AtomType = 't' + AtomList AtomType = 'L' + AtomMap AtomType = 'M' + AtomBLOB AtomType = 'B' + AtomPInt AtomType = '+' + AtomNInt AtomType = '-' + AtomFloatNaN AtomType = '_' + AtomFloatPinf AtomType = '>' + AtomFloatNinf AtomType = '<' + AtomFloat AtomType = '~' + AtomTAI64 AtomType = 'T' + AtomTAI64N AtomType = 'N' + AtomTAI64NA AtomType = 'A' + AtomMagic AtomType = 'K' AtomStrings = 0x80 AtomIsUTF8 = 0x40 diff --git a/py3/keks.py b/py3/keks.py index 93ca9c2ede075227b84eace415597789aa4e0578a984d5fcdf7c413ef13bdde3..0d2125abc8ba793f63c6898ce0e98ce1e2569dc1ea907c2089a21edfe7fc30bf 100755 --- a/py3/keks.py +++ b/py3/keks.py @@ -40,23 +40,23 @@ from math import ceil as _ceil from math import isnan as _isnan -TagEOC = 0x00 -TagNIL = 0x01 -TagFalse = 0x02 -TagTrue = 0x03 -TagList = 0x08 -TagMap = 0x09 -TagBlob = 0x0B -TagPInt = 0x0C -TagNInt = 0x0D -TagFloatNaN = 0x10 -TagFloatPinf = 0x11 -TagFloatNinf = 0x12 -TagFloat = 0x13 -TagTAI64 = 0x18 -TagTAI64N = 0x19 -TagTAI64NA = 0x1A -TagMagic = 0x4B +TagEOC = ord(".") +TagNIL = ord("!") +TagFalse = ord("f") +TagTrue = ord("t") +TagList = ord("L") +TagMap = ord("M") +TagBlob = ord("B") +TagPInt = ord("+") +TagNInt = ord("-") +TagFloatNaN = ord("_") +TagFloatPinf = ord(">") +TagFloatNinf = ord("<") +TagFloat = ord("~") +TagTAI64 = ord("T") +TagTAI64N = ord("N") +TagTAI64NA = ord("A") +TagMagic = ord("K") TagStr = 0x80 TagUTF8 = 0x40 NaN = float("nan") diff --git a/py3/tests/test_blob.py b/py3/tests/test_blob.py index 85955b55028b5a3287a295966aaabacad91fc8bbdf19c7072626ff7742990471..2078580d8266890c831476a9af4086e2ca9fad2cdfb3d33616f979c1bafd1030 100644 --- a/py3/tests/test_blob.py +++ b/py3/tests/test_blob.py @@ -36,7 +36,8 @@ encoded = dumps(blob) self.assertSequenceEqual( encoded, b"".join(( - bytes.fromhex("0B0C8103"), + b"B", + bytes.fromhex("2B8103"), bytes.fromhex("84"), b"test", bytes.fromhex("84"), b"data", bytes.fromhex("80"), @@ -54,7 +55,8 @@ encoded = dumps(blob) self.assertSequenceEqual( encoded, b"".join(( - bytes.fromhex("0B0C8103"), + b"B", + bytes.fromhex("2B8103"), bytes.fromhex("84"), b"test", bytes.fromhex("84"), b"data", bytes.fromhex("81"), b"2", @@ -72,7 +74,8 @@ encoded = dumps(blob) self.assertSequenceEqual( encoded, b"".join(( - bytes.fromhex("0B0C8103"), + b"B", + bytes.fromhex("2B8103"), bytes.fromhex("80"), )), ) @@ -89,7 +92,7 @@ ) def test_symmetric_multiple(self, chunkLen: int, chunks: int, junk: bytes) -> None: chunks = [urandom(chunkLen) for _ in range(chunks)] encoded = b"".join(( - b"\x0b", + b"B", dumps(chunkLen-1), b"".join(dumps(chunk) for chunk in chunks), b"\x80", @@ -102,7 +105,8 @@ self.assertSequenceEqual(tail, junk) def test_throws_when_not_enough_data(self) -> None: encoded = b"".join(( - bytes.fromhex("0B0C8103"), + b"B", + bytes.fromhex("2B8103"), bytes.fromhex("84"), b"test", bytes.fromhex("84"), b"da", )) @@ -111,14 +115,15 @@ loads(encoded) self.assertEqual(err.exception.n, 2) def test_throws_when_not_enough_data_for_length(self) -> None: - encoded = bytes.fromhex("0B0C81") + encoded = b"B" + bytes.fromhex("2B81") with self.assertRaises(NotEnoughData) as err: loads(encoded) self.assertEqual(err.exception.n, 1) def test_throws_when_wrong_terminator_length(self) -> None: encoded = b"".join(( - bytes.fromhex("0B0C8103"), + b"B", + bytes.fromhex("2B8103"), bytes.fromhex("84"), b"test", bytes.fromhex("84"), b"data", bytes.fromhex("8A"), b"terminator", @@ -129,10 +134,11 @@ self.assertEqual(str(err.exception), "wrong chunk len") def test_throws_when_wrong_terminator_tag(self) -> None: encoded = b"".join(( - bytes.fromhex("0B0C8103"), + b"B", + bytes.fromhex("2B8103"), bytes.fromhex("84"), b"test", bytes.fromhex("84"), b"data", - bytes.fromhex("01"), + b"!", )) with self.assertRaises(DecodeError) as err: loads(encoded) diff --git a/py3/tests/test_bool.py b/py3/tests/test_bool.py index 0acd08df2ba0375035fe614a030fa85288abf2ec0837af29a86d57b35de4ebdb..c2fc0f363be1e4c3e90e5b850c8953f21c6bd83f45d2bec02c75cf26873f317d 100644 --- a/py3/tests/test_bool.py +++ b/py3/tests/test_bool.py @@ -26,22 +26,22 @@ class TestBool(TestCase): def test_encode_true(self): encoded = dumps(True) - self.assertEqual(encoded, b"\x03") + self.assertEqual(encoded, b"t") def test_encode_false(self): encoded = dumps(False) - self.assertEqual(encoded, b"\x02") + self.assertEqual(encoded, b"f") @given(junk_st) def test_decode_true(self, junk): - encoded = b"\x03" + junk + encoded = b"t" + junk decoded, tail = loads(encoded) self.assertIs(decoded, True) self.assertSequenceEqual(tail, junk) @given(junk_st) def test_decode_false(self, junk): - encoded = b"\x02" + junk + encoded = b"f" + junk decoded, tail = loads(encoded) self.assertIs(decoded, False) self.assertSequenceEqual(tail, junk) diff --git a/py3/tests/test_float.py b/py3/tests/test_float.py index d1cabba0f4aac0ad6ce029fde8ce6000bc6bb766655d9778a74d02051b169338..1e20e10a65088fe9c1a5d101a7762e28c0f2e9d95e385366a1f5483677db052c 100644 --- a/py3/tests/test_float.py +++ b/py3/tests/test_float.py @@ -38,7 +38,7 @@ @given(junk_st) def test_nan(self, junk: bytes) -> None: b = dumps(float("nan")) - self.assertSequenceEqual(b, b"\x10") + self.assertSequenceEqual(b, b"_") f, tail = loads(b + junk) self.assertSequenceEqual(tail, junk) self.assertIs(f, NaN) @@ -46,7 +46,7 @@ @given(junk_st) def test_pinf(self, junk: bytes) -> None: b = dumps(float("+inf")) - self.assertSequenceEqual(b, b"\x11") + self.assertSequenceEqual(b, b">") f, tail = loads(b + junk) self.assertSequenceEqual(tail, junk) self.assertEqual(f, float("+inf")) @@ -54,7 +54,7 @@ @given(junk_st) def test_ninf(self, junk: bytes) -> None: b = dumps(float("-inf")) - self.assertSequenceEqual(b, b"\x12") + self.assertSequenceEqual(b, b"<") f, tail = loads(b + junk) self.assertSequenceEqual(tail, junk) self.assertEqual(f, float("-inf")) @@ -62,29 +62,29 @@ @given(junk_st) def test_0(self, junk: bytes) -> None: b = dumps(0.0) - self.assertSequenceEqual(b, b"\x13" + dumps(0) + dumps(0)) + self.assertSequenceEqual(b, b"~" + dumps(0) + dumps(0)) f, tail = loads(b + junk) self.assertSequenceEqual(tail, junk) self.assertEqual(f, 0.0) def test_not_enough(self) -> None: with self.assertRaises(NotEnoughData) as err: - loads(b"\x13") + loads(b"~") self.assertEqual(err.exception.n, 1) def test_not_enough_int(self) -> None: with self.assertRaises(NotEnoughData) as err: - loads(b"\x13" + dumps(123)) + loads(b"~" + dumps(123)) self.assertEqual(err.exception.n, 1) def test_non_int0(self) -> None: with self.assertRaises(DecodeError) as err: - loads(b"\x13" + dumps(False) + dumps(123)) + loads(b"~" + dumps(False) + dumps(123)) self.assertEqual(str(err.exception), "non-int m float") def test_non_int1(self) -> None: with self.assertRaises(DecodeError) as err: - loads(b"\x13" + dumps(123) + dumps(False)) + loads(b"~" + dumps(123) + dumps(False)) self.assertEqual(str(err.exception), "non-int e float") @given(integers(), integers(), junk_st) diff --git a/py3/tests/test_generic.py b/py3/tests/test_generic.py index a69b552cf6b7004cb60f0facba6b53f0eb2fd5b1cffe2b82ac34267d20e28860..19f869579667d3719469c8b49f0618ea3e0f00aa39398ff3e3623e27fcb3a69c 100644 --- a/py3/tests/test_generic.py +++ b/py3/tests/test_generic.py @@ -39,7 +39,7 @@ class TestUnknownTag(TestCase): def runTest(self) -> None: with self.assertRaises(DecodeError) as err: loads(b"\x05") - self.assertEqual(str(err.exception), "unknown tag") + self.assertEqual(str(err.exception), "unknown tag: 5") class TestEmptyData(TestCase): @@ -58,5 +58,5 @@ class TestLonelyEOC(TestCase): def runTest(self) -> None: with self.assertRaises(DecodeError) as err: - loads(b"\x00") + loads(b".") self.assertEqual(str(err.exception), "unexpected EOC") diff --git a/py3/tests/test_int.py b/py3/tests/test_int.py index 3373571e31215383b23c81080b9fef557d1ff917d27793929340582e2dc45828..100ada64cec82079e939a1891dd12a7dee598473b11ce7fdf9c119b0cb530884 100644 --- a/py3/tests/test_int.py +++ b/py3/tests/test_int.py @@ -30,7 +30,7 @@ class TestInt(TestCase): @given(junk_st) def test_0(self, junk: bytes) -> None: encoded: bytes = dumps(0) - self.assertSequenceEqual(encoded, bytes.fromhex("0C80")) + self.assertSequenceEqual(encoded, bytes.fromhex("2B80")) decoded, tail = loads(encoded) self.assertEqual(decoded, 0) self.assertSequenceEqual(tail, b"") @@ -38,7 +38,7 @@ @given(junk_st) def test_1(self, junk: bytes) -> None: encoded: bytes = dumps(1) - self.assertSequenceEqual(encoded, bytes.fromhex("0C8101")) + self.assertSequenceEqual(encoded, bytes.fromhex("2B8101")) decoded, tail = loads(encoded + junk) self.assertEqual(decoded, 1) self.assertSequenceEqual(tail, junk) @@ -46,7 +46,7 @@ @given(junk_st) def test_123(self, junk: bytes) -> None: encoded: bytes = dumps(123) - self.assertSequenceEqual(encoded, bytes.fromhex("0C817B")) + self.assertSequenceEqual(encoded, bytes.fromhex("2B817B")) decoded, tail = loads(encoded + junk) self.assertEqual(decoded, 123) self.assertSequenceEqual(tail, junk) @@ -56,7 +56,7 @@ def test_1s64(self, junk: bytes) -> None: encoded: bytes = dumps(1 << 64) self.assertSequenceEqual( encoded, - bytes.fromhex("0C89010000000000000000"), + bytes.fromhex("2B89010000000000000000"), ) decoded, tail = loads(encoded + junk) self.assertEqual(decoded, 1 << 64) @@ -67,7 +67,7 @@ def test_1s130(self, junk: bytes) -> None: encoded: bytes = dumps(1 << 130) self.assertSequenceEqual( encoded, - bytes.fromhex("0C910400000000000000000000000000000000"), + bytes.fromhex("2B910400000000000000000000000000000000"), ) decoded, tail = loads(encoded + junk) self.assertEqual(decoded, 1 << 130) @@ -76,7 +76,7 @@ @given(junk_st) def test_m1(self, junk: bytes) -> None: encoded: bytes = dumps(-1) - self.assertSequenceEqual(encoded, bytes.fromhex("0D80")) + self.assertSequenceEqual(encoded, bytes.fromhex("2D80")) decoded, tail = loads(encoded + junk) self.assertEqual(decoded, -1) self.assertSequenceEqual(tail, junk) @@ -84,7 +84,7 @@ @given(junk_st) def test_m123(self, junk: bytes) -> None: encoded: bytes = dumps(-123) - self.assertSequenceEqual(encoded, bytes.fromhex("0D817A")) + self.assertSequenceEqual(encoded, bytes.fromhex("2D817A")) decoded, tail = loads(encoded + junk) self.assertEqual(decoded, -123) self.assertSequenceEqual(tail, junk) @@ -92,7 +92,7 @@ @given(junk_st) def test_m1s64(self, junk: bytes) -> None: encoded: bytes = dumps(-(1 << 64)) - self.assertSequenceEqual(encoded, bytes.fromhex("0D88FFFFFFFFFFFFFFFF")) + self.assertSequenceEqual(encoded, bytes.fromhex("2D88FFFFFFFFFFFFFFFF")) decoded, tail = loads(encoded + junk) self.assertEqual(decoded, -(1 << 64)) self.assertSequenceEqual(tail, junk) @@ -102,7 +102,7 @@ def test_m1s130(self, junk: bytes) -> None: encoded: bytes = dumps(-(1 << 130)) self.assertSequenceEqual( encoded, - bytes.fromhex("0D9103FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"), + bytes.fromhex("2D9103FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"), ) decoded, tail = loads(encoded + junk) self.assertEqual(decoded, -(1 << 130)) @@ -110,21 +110,21 @@ self.assertSequenceEqual(tail, junk) def test_decode_not_enough_data(self) -> None: with self.assertRaises(NotEnoughData) as err: - loads(bytes.fromhex("0C830102")) + loads(bytes.fromhex("2B830102")) self.assertEqual(err.exception.n, 1) with self.assertRaises(NotEnoughData) as err: - loads(bytes.fromhex("0C8301")) + loads(bytes.fromhex("2B8301")) self.assertEqual(err.exception.n, 2) def test_throws_when_nonminimal_int(self) -> None: with self.assertRaises(DecodeError) as err: - encoded: bytes = bytes.fromhex("0C81007B") + encoded: bytes = bytes.fromhex("2B81007B") loads(encoded) self.assertEqual(str(err.exception), "non-minimal encoding") def test_throws_when_non_bin_in_int(self) -> None: with self.assertRaises(DecodeError) as err: - encoded: bytes = bytes.fromhex("0C017B") + encoded: bytes = bytes.fromhex("2B217B") loads(encoded) self.assertEqual(str(err.exception), "non-BIN in INT") diff --git a/py3/tests/test_list.py b/py3/tests/test_list.py index 7d6cf337f0f1fae1547157cf07f84fec2cffa4cdf09fcbe72b68f4efc4e1343c..a9ec6d8f0c32828d7dc7056284bafe2de4f383acd2406d51179070bf29960806 100644 --- a/py3/tests/test_list.py +++ b/py3/tests/test_list.py @@ -32,7 +32,7 @@ class TestList(TestCase): @given(junk_st) def test_empty(self, junk: bytes) -> None: encoded = dumps([]) - self.assertSequenceEqual(encoded, b"\x08\x00") + self.assertSequenceEqual(encoded, b"L.") decoded, tail = loads(encoded + junk) self.assertEqual(decoded, []) self.assertSequenceEqual(tail, junk) @@ -42,7 +42,7 @@ def test_symmetric(self, test_list: List, junk: bytes) -> None: encoded = dumps(test_list) self.assertSequenceEqual( encoded, - b"\x08" + b"".join(dumps(i) for i in test_list) + b"\x00", + b"L" + b"".join(dumps(i) for i in test_list) + b".", ) decoded, tail = loads(encoded + junk) self.assertEqual(decoded, test_list) diff --git a/py3/tests/test_map.py b/py3/tests/test_map.py index 8f1eca0d832c1c061c4f952c286e84ee38a644f1f6cb62c04c128996b6d2dbc0..240f84f3ac4f40645f38684919338949efe6f8dcf6fdc1a3508cd0745feeb4c2 100644 --- a/py3/tests/test_map.py +++ b/py3/tests/test_map.py @@ -36,7 +36,7 @@ @given(dictionaries(keys=mapkey_st, values=any_st, max_size=4), junk_st) def test_symmetric(self, test_map: Mapping[str, Any], junk: bytes): encoded = dumps(test_map) expected = ( - b"\x09" + + b"M" + b"".join( [ b"".join([dumps(key), dumps(test_map[key])]) @@ -46,7 +46,7 @@ x.encode("utf-8"), )) ] ) + - b"\x00" + b"." ) self.assertSequenceEqual(encoded, expected) decoded, tail = loads(encoded + junk) @@ -57,7 +57,7 @@ @given(junk_st) def test_empty(self, junk): test_map = {} encoded = dumps(test_map) + junk - expected = b"\x09\x00" + junk + expected = b"M." + junk self.assertSequenceEqual(encoded, expected) decoded, tail = loads(encoded) self.assertEqual(decoded, test_map) @@ -65,12 +65,12 @@ self.assertSequenceEqual(tail, junk) def test_throws_when_decoding_unsorted_value_keys(self): encoded = b"".join(( - bytes.fromhex("09"), + b"M", bytes.fromhex("C4"), b"key2", - bytes.fromhex("0C8101"), + bytes.fromhex("2B8101"), bytes.fromhex("C4"), b"key1", bytes.fromhex("C6"), b"value1", - bytes.fromhex("00"), + b".", )) with self.assertRaises(DecodeError) as err: loads(encoded) @@ -78,12 +78,13 @@ self.assertEqual(str(err.exception), "unsorted keys") def test_throws_when_decoding_unsorted_len_keys(self): encoded = b"".join(( - bytes.fromhex("09"), + b"M", bytes.fromhex("C4"), b"key2", - bytes.fromhex("0C8101"), + bytes.fromhex("2B8101"), bytes.fromhex("C3"), b"key", bytes.fromhex("C6"), b"value1", bytes.fromhex("00"), + b".", )) with self.assertRaises(DecodeError) as err: loads(encoded) @@ -96,9 +97,9 @@ self.assertEqual(str(err.exception), "map keys can be only strings") def test_throws_when_decoding_non_string_key(self): encoded = b"".join(( - bytes.fromhex("09"), - bytes.fromhex("0C80C6"), b"value2", - bytes.fromhex("00"), + b"M", + bytes.fromhex("2B80C6"), b"value2", + b".", )) with self.assertRaises(DecodeError) as err: loads(encoded) @@ -106,10 +107,10 @@ self.assertEqual(str(err.exception), "non-string key") def test_throws_when_unexpected_eoc(self): encoded = b"".join(( - bytes.fromhex("09"), + b"M", bytes.fromhex("C4"), b"key1", - bytes.fromhex("00"), - bytes.fromhex("00"), + b".", + b".", )) with self.assertRaises(DecodeError) as err: decoded, tail = loads(encoded) @@ -121,7 +122,7 @@ dumps({"": "a"}) self.assertEqual(str(err.exception), "map keys can not be empty") def test_throws_when_decoding_empty_str_as_key(self): - encoded = bytes.fromhex("09" + "C0" + "C0" + "00") + encoded = b"M" + bytes.fromhex("C0" + "C0") + b"." with self.assertRaises(DecodeError) as err: decoded, tail = loads(encoded) self.assertEqual(str(err.exception), "empty key") @@ -154,5 +155,5 @@ s2 = bytes.fromhex("f1aaab9ec3adc2bcc3b4c3bec38a0cc3ac").decode("utf-8") encoded = dumps(set((s1, s2))) self.assertSequenceEqual( encoded.hex(), - (b"".join((b"\x09", dumps(s1), b"\x01", dumps(s2), b"\x01", b"\x00"))).hex(), + (b"".join((b"M", dumps(s1), b"!", dumps(s2), b"!", b"."))).hex(), ) diff --git a/py3/tests/test_tai.py b/py3/tests/test_tai.py index e213dafbfa93aac6acb3fd781e921da88e63989054b282b01491200d0caf6b3a..9ee0b0341f5e1efae97e7a9bddee51e55c1812bb21c8b2b2789b82045c8e6b06 100644 --- a/py3/tests/test_tai.py +++ b/py3/tests/test_tai.py @@ -31,9 +31,9 @@ from keks import TAI64Base from tests.strategies import junk_st -TagTAI64 = 0x18 -TagTAI64N = 0x19 -TagTAI64NA = 0x1A +TagTAI64 = ord("T") +TagTAI64N = ord("N") +TagTAI64NA = ord("A") # This is output of: curl http://cr.yp.to/libtai/leapsecs.dat | xxd -c 8 -p DJB_Leapsecs = ( @@ -78,19 +78,19 @@ self.assertSequenceEqual(tail, junk) def test_throws_when_not_enough_data(self) -> None: with self.assertRaises(NotEnoughData) as err: - loads(b"\x18" + b"\x00" * (8-1)) + loads(b"T" + b"\x00" * (8-1)) self.assertEqual(err.exception.n, 1) def test_large_number_of_secs(self) -> None: - decoded, tail = loads(bytes.fromhex("187000000065195F65")) + decoded, tail = loads(bytes.fromhex("547000000065195F65")) self.assertEqual(decoded, Raw( - _byte(0x18) + bytes.fromhex("7000000065195F65")), + b"T" + bytes.fromhex("7000000065195F65")), ) self.assertSequenceEqual(tail, b"") def test_throws_when_msb_is_set(self) -> None: with self.assertRaises(DecodeError) as err: - loads(bytes.fromhex("188000000065195F65")) + loads(bytes.fromhex("548000000065195F65")) self.assertEqual(str(err.exception), "reserved TAI64 value is in use") def test_leapsecUTCAllow_is_passed_through_containers(self) -> None: @@ -115,21 +115,21 @@ self.assertSequenceEqual(tail, junk) def test_throws_when_not_enough_data(self) -> None: with self.assertRaises(NotEnoughData) as err: - loads(b"\x19" + b"\x00" * (12-2)) + loads(b"N" + b"\x00" * (12-2)) self.assertEqual(err.exception.n, 2) def test_nanoseconds_not_convertible_to_microseconds(self) -> None: - decoded, tail = loads(bytes.fromhex("194000000065195F65075BCA01")) + decoded, tail = loads(bytes.fromhex("4E4000000065195F65075BCA01")) self.assertEqual( decoded, - Raw(_byte(0x19) + bytes.fromhex("4000000065195F65075BCA01")), + Raw(b"N" + bytes.fromhex("4000000065195F65075BCA01")), ) self.assertSequenceEqual(tail, b"") def test_throws_when_too_many_nanosecs(self) -> None: with self.assertRaises(DecodeError) as err: loads( - bytes.fromhex("194000000065195F65") + + bytes.fromhex("4E4000000065195F65") + (999999999 + 1).to_bytes(4, "big") ) self.assertEqual(str(err.exception), "too many nanoseconds") @@ -137,18 +137,18 @@ def test_zero_nanoseconds(self) -> None: with self.assertRaises(DecodeError) as err: loads( - bytes.fromhex("194000000000000000") + + bytes.fromhex("4E4000000000000000") + bytes.fromhex("00000000") ) self.assertEqual(str(err.exception), "non-minimal TAI64N") def test_large_number_of_secs(self) -> None: decoded, tail = loads( - bytes.fromhex("197000000065195F65") + + bytes.fromhex("4E7000000065195F65") + bytes.fromhex("00010000") ) self.assertEqual(decoded, Raw( - _byte(0x19) + + b"N" + bytes.fromhex("7000000065195F65") + bytes.fromhex("00010000"), )) @@ -157,7 +157,7 @@ def test_throws_when_msb_is_set(self) -> None: with self.assertRaises(DecodeError) as err: loads( - bytes.fromhex("198000000065195F65") + + bytes.fromhex("4E8000000065195F65") + bytes.fromhex("00010000") ) self.assertEqual(str(err.exception), "reserved TAI64 value is in use") @@ -166,26 +166,26 @@ class TestTAI64NA(TestCase): @given(junk_st) def test_decode(self, junk: bytes) -> None: - encoded = bytes.fromhex("1A4000000065195F65075BCA00075BCA00") + junk - expected = Raw(_byte(0x1A) + bytes.fromhex("4000000065195F65075BCA00075BCA00")) + encoded = bytes.fromhex("414000000065195F65075BCA00075BCA00") + junk + expected = Raw(b"A" + bytes.fromhex("4000000065195F65075BCA00075BCA00")) decoded, tail = loads(encoded) self.assertEqual(decoded, expected) self.assertSequenceEqual(tail, junk) def test_throws_when_not_enough_data(self) -> None: with self.assertRaises(NotEnoughData) as err: - loads(b"\x1a" + b"\x00" * (16-3)) + loads(b"A" + b"\x00" * (16-3)) self.assertEqual(err.exception.n, 3) def test_throws_when_too_many_attosecs(self) -> None: with self.assertRaises(DecodeError) as err: - loads(bytes.fromhex("1A4000000065195F65075BCA00A75BCA00")) + loads(bytes.fromhex("414000000065195F65075BCA00A75BCA00")) self.assertEqual(str(err.exception), "too many attoseconds") def test_zero_attoseconds(self) -> None: with self.assertRaises(DecodeError) as err: loads( - bytes.fromhex("1A4000000000000000") + + bytes.fromhex("414000000000000000") + bytes.fromhex("00000000") + bytes.fromhex("00000000") ) @@ -193,19 +193,19 @@ self.assertEqual(str(err.exception), "non-minimal TAI64NA") def test_zero_nanoseconds_ok_for_tai64na(self) -> None: loads( - bytes.fromhex("1A4000000000000000") + + bytes.fromhex("414000000000000000") + bytes.fromhex("00000000") + bytes.fromhex("00000001") ) def test_large_number_of_secs(self) -> None: decoded, tail = loads( - bytes.fromhex("1A7000000065195F65") + + bytes.fromhex("417000000065195F65") + bytes.fromhex("00010000") + bytes.fromhex("00010000") ) self.assertEqual(decoded, Raw( - _byte(0x1A) + + b"A" + bytes.fromhex("7000000065195F65") + 2 * bytes.fromhex("00010000"), )) @@ -214,7 +214,7 @@ def test_throws_when_msb_is_set(self) -> None: with self.assertRaises(DecodeError) as err: loads( - bytes.fromhex("1A8000000065195F65") + + bytes.fromhex("418000000065195F65") + bytes.fromhex("00010000") + bytes.fromhex("00010000") ) @@ -223,27 +223,27 @@ class TestVectors(TestCase): def test_19700101(self) -> None: - decoded, _ = loads(bytes.fromhex("18400000000000000A")) + decoded, _ = loads(bytes.fromhex("54400000000000000A")) self.assertEqual(decoded, datetime(1970, 1, 1, 0, 0)) def test_19920602(self) -> None: - decoded, _ = loads(bytes.fromhex("18400000002A2B2C2D")) + decoded, _ = loads(bytes.fromhex("54400000002A2B2C2D")) self.assertEqual(decoded, datetime(1992, 6, 2, 8, 6, 43)) def test_19971003(self) -> None: - decoded, _ = loads(bytes.fromhex("184000000034353637")) + decoded, _ = loads(bytes.fromhex("544000000034353637")) self.assertEqual(decoded, datetime(1997, 10, 3, 18, 14, 48)) def test_20161231(self) -> None: - decoded, _ = loads(bytes.fromhex("1840000000586846A3")) + decoded, _ = loads(bytes.fromhex("5440000000586846A3")) self.assertEqual(decoded, datetime(2016, 12, 31, 23, 59, 59)) def test_20170101(self) -> None: - decoded, _ = loads(bytes.fromhex("1840000000586846A5")) + decoded, _ = loads(bytes.fromhex("5440000000586846A5")) self.assertEqual(decoded, datetime(2017, 1, 1, 0, 0)) def test_20241120(self) -> None: - decoded, _ = loads(bytes.fromhex("1940000000673DD3E136F11FE0")) + decoded, _ = loads(bytes.fromhex("4E40000000673DD3E136F11FE0")) self.assertEqual(decoded, datetime(2024, 11, 20, 12, 19, 8, 921772)) @@ -260,12 +260,12 @@ def test_decode(self) -> None: for leapsec in DJB_Leapsecs: decoded, tail = loads( - v=b"\x18" + bytes.fromhex(leapsec), + v=b"T" + bytes.fromhex(leapsec), leapsecUTCAllow=True, ) self.assertIsInstance(decoded, datetime) decoded, tail = loads( - v=b"\x18" + bytes.fromhex(leapsec), + v=b"T" + bytes.fromhex(leapsec), leapsecUTCAllow=False, ) self.assertIsInstance(decoded, Raw) diff --git a/spec/encoding/BLOB b/spec/encoding/BLOB index 22dddc12a9dcaead7cf4637d96ecbefc01adba4166a4ed18d668346cbe4601ed..54c75fb606755ace2de2c85b878df0de6d436b98c869de54957498fc5a3c6561 100644 --- a/spec/encoding/BLOB +++ b/spec/encoding/BLOB @@ -14,8 +14,8 @@ BLOB INT(chunk-len) [BIN(len=chunk-len) || ...] BIN(len | 3E | 00111110 | 0 | [encoding/FLOAT] +inf + ~ | 7E | 01111110 | 4+~ | [encoding/FLOAT] + + | 2B | 00101011 | 1+~ | + [encoding/INT] + - | 2D | 00101101 | 1+~ | - [encoding/INT] + + | 80 | 10000000 | 0 | Binary [encoding/String] len=0 + | 81 | 10000001 | 1 | Binary [encoding/String] len=1 + | ... | ... | ... | ... + | BC | 10111100 | 60 | Binary [encoding/String] len=60 + | BD | 10111101 | 1+~ | Binary [encoding/String] 8b len + | BE | 10111110 | 2+~ | Binary [encoding/String] 16b len + | BF | 10111111 | 8+~ | Binary [encoding/String] 64b len + + | C0 | 11000000 | 0 | UTF-8 [encoding/String] len=0 + | C1 | 11000001 | 1 | UTF-8 [encoding/String] len=1 + | ... | ... | ... | ... + | FC | 11111100 | 60 | UTF-8 [encoding/String] len=60 + | FD | 11111101 | 1+~ | UTF-8 [encoding/String] len of 8b + | FE | 11111110 | 2+~ | UTF-8 [encoding/String] len of 16b + | FF | 11111111 | 8+~ | UTF-8 [encoding/String] len of 64b diff --git a/tcl/keks.tcl b/tcl/keks.tcl index 7f783b2d6f906cad21239e768521b84f43c3d1d10c9c28457488f2597902c20b..9cf34ff308aa45c073a28a6acb1299f50e351cc3686929c0ebd17eace563c503 100644 --- a/tcl/keks.tcl +++ b/tcl/keks.tcl @@ -20,11 +20,6 @@ upvar buf buf set buf [string cat $buf $v] } -proc char {v} { - upvar buf buf - add [binary format c $v] -} - ######################################################################## # v is a complete raw value of the atom. @@ -35,22 +30,22 @@ } proc EOC {} { upvar buf buf - char [expr 0x00] + add . } proc NIL {} { upvar buf buf - char [expr 0x01] + add ! } proc FALSE {} { upvar buf buf - char [expr 0x02] + add f } proc TRUE {} { upvar buf buf - char [expr 0x03] + add t } ######################################################################## @@ -87,7 +82,7 @@ set ll 1 set vl [expr {$vl - 61}] } upvar buf buf - char [expr {$atom | $lv}] + add [binary format c [expr {$atom | $lv}]] if {$ll > 0} { toBE $ll $vl } @@ -106,7 +101,7 @@ } proc BLOB {chunkLen v} { upvar buf buf - char [expr 0x0B] + add B INT [expr {$chunkLen - 1}] set vl [strlen $v] set chunks [expr {$vl / $chunkLen}] @@ -156,9 +151,9 @@ proc INT {v} { upvar buf buf if {$v >= 0} { - char [expr 0x0C] + add + } else { - char [expr 0x0D] + add - set v [expr {- ($v + 1)}] } if {$v == 0} { @@ -180,16 +175,16 @@ proc FLOAT {v} { upvar buf buf switch -- $v { nan { - char [expr 0x10] + add _ } +inf { - char [expr 0x11] + add > } -inf { - char [expr 0x12] + add < } default { - char [expr 0x13] + add ~ INT [lindex $v 0] INT [lindex $v 1] } @@ -201,7 +196,7 @@ # v is a list of values that will be eval-ed. proc LIST {v} { upvar buf buf - char [expr 0x08] + add L foreach i $v { eval $i } @@ -244,7 +239,7 @@ dict set d $k $v } set keys [lsort -command LenFirstSort $keys] upvar buf buf - char [expr 0x09] + add M foreach k $keys { STR $k eval [dict get $d $k] @@ -328,16 +323,16 @@ proc TAI64 {v {n 0} {a 0}} { upvar buf buf set v [expr {$v + (1<<62)}] if {$a != 0} { - char [expr 0x1A] + add A toBE 8 $v toBE 4 $n toBE 4 $a } elseif {$n != 0} { - char [expr 0x19] + add N toBE 8 $v toBE 4 $n } else { - char [expr 0x18] + add T toBE 8 $v } } diff --git a/tcl/mk-fuzz-inputs b/tcl/mk-fuzz-inputs index e5e80a4a808071ac334773309933ca2697f9d5542d7ce56d1300ba486469bbbb..99e0ecb4c31bbde2c6b3ba58229d79ceb40ef625bbac934e6e7c984b6f7e4129 100755 --- a/tcl/mk-fuzz-inputs +++ b/tcl/mk-fuzz-inputs @@ -1,7 +1,9 @@ #!/bin/sh -e +d="$(dirname "$(realpath -- "$0")")" + dump() { - echo "$@" | ${TCLSH:-tclsh} keks.tcl + echo "$@" | ${TCLSH:-tclsh} $d/keks.tcl } dump 'BIN ""' >bin-empty @@ -28,7 +30,7 @@ dump 'MAP {}' >map-empty dump 'MAP {a {LIST {NIL}}}' >map-foo dump 'TAI64 [ToTAI [ISOToSec "1970-01-01 00:00:00"]]' >tai-utc0 dump 'TAI64 -1' >tai-before -dump 'RAW [hexdec "1840000000586846A4"]' >tai-leap +dump 'RAW [hexdec "5440000000586846A4"]' >tai-leap dump 'TAI64 1234 1234' >tai-ns dump 'TAI64 1234 1234 1234' >tai-as dump "MAGIC fuzz" >magic