From 5d08331d2b52afe8694e5d307fd6686d874ed012 Mon Sep 17 00:00:00 2001 From: illia-li Date: Fri, 27 Sep 2024 09:22:20 -0400 Subject: [PATCH 1/7] add boolean test --- marshal_1_boolean_test.go | 48 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+) create mode 100644 marshal_1_boolean_test.go diff --git a/marshal_1_boolean_test.go b/marshal_1_boolean_test.go new file mode 100644 index 00000000..f5fb3e78 --- /dev/null +++ b/marshal_1_boolean_test.go @@ -0,0 +1,48 @@ +package gocql_test + +import ( + "testing" + + "github.com/gocql/gocql" + "github.com/gocql/gocql/marshal/tests/mod" + "github.com/gocql/gocql/marshal/tests/serialization" +) + +func TestMarshalBoolean(t *testing.T) { + tType := gocql.NewNativeType(4, gocql.TypeBoolean, "") + + marshal := func(i interface{}) ([]byte, error) { return gocql.Marshal(tType, i) } + unmarshal := func(bytes []byte, i interface{}) error { + return gocql.Unmarshal(tType, bytes, i) + } + + serialization.Set{ + Data: nil, + Values: mod.Values{(*bool)(nil)}.AddVariants(mod.CustomType), + }.Run("[nil]nullable", t, marshal, unmarshal) + + serialization.Set{ + Data: nil, + Values: mod.Values{false}.AddVariants(mod.CustomType), + }.Run("[nil]unmarshal", t, nil, unmarshal) + + serialization.Set{ + Data: make([]byte, 0), + Values: mod.Values{false}.AddVariants(mod.All...), + }.Run("[]unmarshal", t, nil, unmarshal) + + serialization.Set{ + Data: []byte("\x00"), + Values: mod.Values{false}.AddVariants(mod.All...), + }.Run("zeros", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x01"), + Values: mod.Values{true}.AddVariants(mod.All...), + }.Run("[ff]unmarshal", t, nil, unmarshal) + + serialization.Set{ + Data: []byte("\xff"), + Values: mod.Values{true}.AddVariants(mod.All...), + }.Run("[01]", t, nil, unmarshal) +} From 836a94ebd544affd8786c232621cf7bf7eb04202 Mon Sep 17 00:00:00 2001 From: illia-li Date: Fri, 27 Sep 2024 12:19:12 -0400 Subject: [PATCH 2/7] add tinyint test --- marshal_2_tinyint_test.go | 92 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 92 insertions(+) create mode 100644 marshal_2_tinyint_test.go diff --git a/marshal_2_tinyint_test.go b/marshal_2_tinyint_test.go new file mode 100644 index 00000000..64eab354 --- /dev/null +++ b/marshal_2_tinyint_test.go @@ -0,0 +1,92 @@ +package gocql_test + +import ( + "math/big" + "testing" + + "github.com/gocql/gocql" + "github.com/gocql/gocql/internal/tests/utils" + "github.com/gocql/gocql/marshal/tests/mod" + "github.com/gocql/gocql/marshal/tests/serialization" +) + +func TestMarshalTinyint(t *testing.T) { + tType := gocql.NewNativeType(4, gocql.TypeTinyInt, "") + + marshal := func(i interface{}) ([]byte, error) { return gocql.Marshal(tType, i) } + unmarshal := func(bytes []byte, i interface{}) error { + return gocql.Unmarshal(tType, bytes, i) + } + + // unmarshal `custom string` unsupported + brokenCustomStrings := utils.GetTypes(mod.String(""), (*mod.String)(nil)) + + // marshal "" (empty string) unsupported + // unmarshal nil value into (string)("0") + brokenEmptyStrings := utils.GetTypes(string(""), mod.String("")) + + // marshal `custom string` unsupported + // marshal `big.Int` unsupported + brokenMarshalTypes := append(brokenCustomStrings, utils.GetTypes(big.Int{}, &big.Int{})...) + + serialization.Set{ + Data: nil, + Values: mod.Values{ + (*int8)(nil), (*int16)(nil), (*int32)(nil), (*int64)(nil), (*int)(nil), + (*uint8)(nil), (*uint16)(nil), (*uint32)(nil), (*uint64)(nil), (*uint)(nil), + (*string)(nil), (*big.Int)(nil), string(""), + }.AddVariants(mod.CustomType), + BrokenMarshalTypes: brokenEmptyStrings, + BrokenUnmarshalTypes: brokenEmptyStrings, + }.Run("[nil]nullable", t, marshal, unmarshal) + + serialization.Set{ + Data: nil, + Values: mod.Values{ + int8(0), int16(0), int32(0), int64(0), int(0), + uint8(0), uint16(0), uint32(0), uint64(0), uint(0), + "0", big.Int{}, + }.AddVariants(mod.CustomType), + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("[nil]unmarshal", t, nil, unmarshal) + + serialization.Set{ + Data: make([]byte, 0), + Values: mod.Values{ + int8(0), int16(0), int32(0), int64(0), int(0), + uint8(0), uint16(0), uint32(0), uint64(0), uint(0), + "0", *big.NewInt(0), + }.AddVariants(mod.All...), + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("[]unmarshal", t, nil, unmarshal) + + serialization.Set{ + Data: []byte("\x00"), + Values: mod.Values{ + int8(0), int16(0), int32(0), int64(0), int(0), + uint8(0), uint16(0), uint32(0), uint64(0), uint(0), + "0", *big.NewInt(0), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenMarshalTypes, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("zeros", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x7f"), + Values: mod.Values{int8(127), int16(127), int32(127), int64(127), int(127), "127", *big.NewInt(127)}.AddVariants(mod.All...), + BrokenMarshalTypes: brokenMarshalTypes, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("127", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x80"), + Values: mod.Values{int8(-128), int16(-128), int32(-128), int64(-128), int(-128), "-128", *big.NewInt(-128)}.AddVariants(mod.All...), + BrokenMarshalTypes: brokenMarshalTypes, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("-128", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\xff"), + Values: mod.Values{uint8(255), uint16(255), uint32(255), uint64(255), uint(255)}.AddVariants(mod.All...), + }.Run("255", t, marshal, unmarshal) +} From 850bade34d106bfbd9a3bb40140c8b6b772aeade Mon Sep 17 00:00:00 2001 From: illia-li Date: Fri, 27 Sep 2024 12:19:47 -0400 Subject: [PATCH 3/7] fix smallint test --- marshal_3_smallint_test.go | 73 ++++++++++++++++++++++++-------------- 1 file changed, 46 insertions(+), 27 deletions(-) diff --git a/marshal_3_smallint_test.go b/marshal_3_smallint_test.go index 7d2a3795..85997bfd 100644 --- a/marshal_3_smallint_test.go +++ b/marshal_3_smallint_test.go @@ -1,83 +1,102 @@ -package gocql +package gocql_test import ( + "math/big" "testing" + "github.com/gocql/gocql" "github.com/gocql/gocql/internal/tests/utils" "github.com/gocql/gocql/marshal/tests/mod" "github.com/gocql/gocql/marshal/tests/serialization" ) func TestMarshalSmallint(t *testing.T) { - marshal := func(i interface{}) ([]byte, error) { return Marshal(NativeType{proto: 4, typ: TypeSmallInt}, i) } + tType := gocql.NewNativeType(4, gocql.TypeSmallInt, "") + + marshal := func(i interface{}) ([]byte, error) { return gocql.Marshal(tType, i) } unmarshal := func(bytes []byte, i interface{}) error { - return Unmarshal(NativeType{proto: 4, typ: TypeSmallInt}, bytes, i) + return gocql.Unmarshal(tType, bytes, i) } - brokenTypes := utils.GetTypes(mod.String(""), (*mod.String)(nil)) + // unmarshal `custom string` unsupported + brokenCustomStrings := utils.GetTypes(mod.String(""), (*mod.String)(nil)) + + // marshal "" (empty string) unsupported + // unmarshal nil value into (string)("0") + brokenEmptyStrings := utils.GetTypes(string(""), mod.String("")) + + // marshal `custom string` unsupported + // marshal `big.Int` unsupported + brokenMarshalTypes := append(brokenCustomStrings, utils.GetTypes(big.Int{}, &big.Int{})...) serialization.Set{ Data: nil, Values: mod.Values{ (*int8)(nil), (*int16)(nil), (*int32)(nil), (*int64)(nil), (*int)(nil), - (*uint8)(nil), (*uint16)(nil), (*uint32)(nil), (*uint64)(nil), (*uint)(nil), (*string)(nil), + (*uint8)(nil), (*uint16)(nil), (*uint32)(nil), (*uint64)(nil), (*uint)(nil), + (*string)(nil), (*big.Int)(nil), "", }.AddVariants(mod.CustomType), - }.Run("[nil]refs", t, marshal, unmarshal) + BrokenMarshalTypes: brokenEmptyStrings, + BrokenUnmarshalTypes: brokenEmptyStrings, + }.Run("[nil]nullable", t, marshal, unmarshal) serialization.Set{ Data: nil, Values: mod.Values{ int8(0), int16(0), int32(0), int64(0), int(0), - uint8(0), uint16(0), uint32(0), uint64(0), uint(0), "0", + uint8(0), uint16(0), uint32(0), uint64(0), uint(0), + "0", big.Int{}, }.AddVariants(mod.CustomType), - BrokenUnmarshalTypes: brokenTypes, - }.Run("unmarshal nil data", t, nil, unmarshal) + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("[nil]unmarshal", t, nil, unmarshal) serialization.Set{ Data: make([]byte, 0), Values: mod.Values{ int8(0), int16(0), int32(0), int64(0), int(0), - uint8(0), uint16(0), uint32(0), uint64(0), uint(0), "0", + uint8(0), uint16(0), uint32(0), uint64(0), uint(0), + "0", *big.NewInt(0), }.AddVariants(mod.All...), - BrokenUnmarshalTypes: brokenTypes, - }.Run("unmarshal zero data", t, nil, unmarshal) + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("[]unmarshal", t, nil, unmarshal) serialization.Set{ Data: []byte("\x00\x00"), Values: mod.Values{ int8(0), int16(0), int32(0), int64(0), int(0), - uint8(0), uint16(0), uint32(0), uint64(0), uint(0), "0", + uint8(0), uint16(0), uint32(0), uint64(0), uint(0), + "0", *big.NewInt(0), }.AddVariants(mod.All...), - BrokenMarshalTypes: brokenTypes, - BrokenUnmarshalTypes: brokenTypes, + BrokenMarshalTypes: brokenMarshalTypes, + BrokenUnmarshalTypes: brokenCustomStrings, }.Run("zeros", t, marshal, unmarshal) serialization.Set{ Data: []byte("\x00\x7f"), - Values: mod.Values{int8(127), int16(127), int32(127), int64(127), int(127), "127"}.AddVariants(mod.All...), - BrokenMarshalTypes: brokenTypes, - BrokenUnmarshalTypes: brokenTypes, + Values: mod.Values{int8(127), int16(127), int32(127), int64(127), int(127), "127", *big.NewInt(127)}.AddVariants(mod.All...), + BrokenMarshalTypes: brokenMarshalTypes, + BrokenUnmarshalTypes: brokenCustomStrings, }.Run("127", t, marshal, unmarshal) serialization.Set{ Data: []byte("\xff\x80"), - Values: mod.Values{int8(-128), int16(-128), int32(-128), int64(-128), int(-128), "-128"}.AddVariants(mod.All...), - BrokenMarshalTypes: brokenTypes, - BrokenUnmarshalTypes: brokenTypes, + Values: mod.Values{int8(-128), int16(-128), int32(-128), int64(-128), int(-128), "-128", *big.NewInt(-128)}.AddVariants(mod.All...), + BrokenMarshalTypes: brokenMarshalTypes, + BrokenUnmarshalTypes: brokenCustomStrings, }.Run("-128", t, marshal, unmarshal) serialization.Set{ Data: []byte("\x7f\xff"), - Values: mod.Values{int16(32767), int32(32767), int64(32767), int(32767), "32767"}.AddVariants(mod.All...), - BrokenMarshalTypes: brokenTypes, - BrokenUnmarshalTypes: brokenTypes, + Values: mod.Values{int16(32767), int32(32767), int64(32767), int(32767), "32767", *big.NewInt(32767)}.AddVariants(mod.All...), + BrokenMarshalTypes: brokenMarshalTypes, + BrokenUnmarshalTypes: brokenCustomStrings, }.Run("32767", t, marshal, unmarshal) serialization.Set{ Data: []byte("\x80\x00"), - Values: mod.Values{int16(-32768), int32(-32768), int64(-32768), int(-32768), "-32768"}.AddVariants(mod.All...), - BrokenMarshalTypes: brokenTypes, - BrokenUnmarshalTypes: brokenTypes, + Values: mod.Values{int16(-32768), int32(-32768), int64(-32768), int(-32768), "-32768", *big.NewInt(-32768)}.AddVariants(mod.All...), + BrokenMarshalTypes: brokenMarshalTypes, + BrokenUnmarshalTypes: brokenCustomStrings, }.Run("-32768", t, marshal, unmarshal) serialization.Set{ From eea180f73a508ee263967c47a5d25e7e83472c3b Mon Sep 17 00:00:00 2001 From: illia-li Date: Fri, 27 Sep 2024 12:20:10 -0400 Subject: [PATCH 4/7] add int test --- marshal_4_int_test.go | 158 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 158 insertions(+) create mode 100644 marshal_4_int_test.go diff --git a/marshal_4_int_test.go b/marshal_4_int_test.go new file mode 100644 index 00000000..29bcc6eb --- /dev/null +++ b/marshal_4_int_test.go @@ -0,0 +1,158 @@ +package gocql_test + +import ( + "math/big" + "testing" + + "github.com/gocql/gocql" + "github.com/gocql/gocql/internal/tests/utils" + "github.com/gocql/gocql/marshal/tests/mod" + "github.com/gocql/gocql/marshal/tests/serialization" +) + +func TestMarshalInt(t *testing.T) { + tType := gocql.NewNativeType(4, gocql.TypeInt, "") + + marshal := func(i interface{}) ([]byte, error) { return gocql.Marshal(tType, i) } + unmarshal := func(bytes []byte, i interface{}) error { + return gocql.Unmarshal(tType, bytes, i) + } + + // unmarshal `custom string` unsupported + brokenCustomStrings := utils.GetTypes(mod.String(""), (*mod.String)(nil)) + + // marshal "" (empty string) unsupported + // unmarshal nil value into (string)("0") + brokenEmptyStrings := utils.GetTypes(string(""), mod.String("")) + + // marshal `custom string` unsupported + // marshal `big.Int` unsupported + brokenMarshalTypes := append(brokenCustomStrings, utils.GetTypes(big.Int{}, &big.Int{})...) + + // marshal data, which equal math.MaxUint32, into uint32, uit64, uint leads to an error + brokenUints := utils.GetTypes(mod.Uint32(0), mod.Uint64(0), mod.Uint(0), (*mod.Uint32)(nil), (*mod.Uint64)(nil), (*mod.Uint)(nil)) + + serialization.Set{ + Data: nil, + Values: mod.Values{ + (*int8)(nil), (*int16)(nil), (*int32)(nil), (*int64)(nil), (*int)(nil), + (*uint8)(nil), (*uint16)(nil), (*uint32)(nil), (*uint64)(nil), (*uint)(nil), + (*string)(nil), (*big.Int)(nil), "", + }.AddVariants(mod.CustomType), + BrokenMarshalTypes: brokenEmptyStrings, + BrokenUnmarshalTypes: brokenEmptyStrings, + }.Run("[nil]nullable", t, marshal, unmarshal) + + serialization.Set{ + Data: nil, + Values: mod.Values{ + int8(0), int16(0), int32(0), int64(0), int(0), + uint8(0), uint16(0), uint32(0), uint64(0), uint(0), + "0", big.Int{}, + }.AddVariants(mod.CustomType), + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("[nil]unmarshal", t, nil, unmarshal) + + serialization.Set{ + Data: make([]byte, 0), + Values: mod.Values{ + int8(0), int16(0), int32(0), int64(0), int(0), + uint8(0), uint16(0), uint32(0), uint64(0), uint(0), + "0", *big.NewInt(0), + }.AddVariants(mod.All...), + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("[]unmarshal", t, nil, unmarshal) + + serialization.Set{ + Data: []byte("\x00\x00\x00\x00"), + Values: mod.Values{ + int8(0), int16(0), int32(0), int64(0), int(0), + uint8(0), uint16(0), uint32(0), uint64(0), uint(0), + "0", *big.NewInt(0), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenMarshalTypes, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("zeros", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x7f\xff\xff\xff"), + Values: mod.Values{ + int32(2147483647), int64(2147483647), int(2147483647), + "2147483647", *big.NewInt(2147483647), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenMarshalTypes, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("2147483647", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x80\x00\x00\x00"), + Values: mod.Values{ + int32(-2147483648), int64(-2147483648), int(-2147483648), + "-2147483648", *big.NewInt(-2147483648), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenMarshalTypes, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("-2147483648", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x00\x00\x7f\xff"), + Values: mod.Values{ + int16(32767), int32(32767), int64(32767), int(32767), + "32767", *big.NewInt(32767), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenMarshalTypes, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("32767", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\xff\xff\x80\x00"), + Values: mod.Values{ + int16(-32768), int32(-32768), int64(-32768), int(-32768), + "-32768", *big.NewInt(-32768), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenMarshalTypes, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("-32768", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x00\x00\x00\x7f"), + Values: mod.Values{ + int8(127), int16(127), int32(127), int64(127), int(127), + "127", *big.NewInt(127), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenMarshalTypes, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("127", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\xff\xff\xff\x80"), + Values: mod.Values{ + int8(-128), int16(-128), int32(-128), int64(-128), int(-128), + "-128", *big.NewInt(-128), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenMarshalTypes, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("-128", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x00\x00\x00\xff"), + Values: mod.Values{ + uint8(255), uint16(255), uint32(255), uint64(255), uint(255), + }.AddVariants(mod.All...), + }.Run("255", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x00\x00\xff\xff"), + Values: mod.Values{ + uint16(65535), uint32(65535), uint64(65535), uint(65535), + }.AddVariants(mod.All...), + }.Run("65535", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\xff\xff\xff\xff"), + Values: mod.Values{ + uint32(4294967295), uint64(4294967295), uint(4294967295), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenUints, + }.Run("4294967295", t, marshal, unmarshal) +} From 0be3d2c0bd350d6277879926877ef5440920fd00 Mon Sep 17 00:00:00 2001 From: illia-li Date: Fri, 27 Sep 2024 12:33:57 -0400 Subject: [PATCH 5/7] add bigint test --- marshal_5_bigint_test.go | 185 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 185 insertions(+) create mode 100644 marshal_5_bigint_test.go diff --git a/marshal_5_bigint_test.go b/marshal_5_bigint_test.go new file mode 100644 index 00000000..45f35030 --- /dev/null +++ b/marshal_5_bigint_test.go @@ -0,0 +1,185 @@ +package gocql_test + +import ( + "math/big" + "testing" + + "github.com/gocql/gocql" + "github.com/gocql/gocql/internal/tests/utils" + "github.com/gocql/gocql/marshal/tests/mod" + "github.com/gocql/gocql/marshal/tests/serialization" +) + +func TestMarshalBigInt(t *testing.T) { + tType := gocql.NewNativeType(4, gocql.TypeBigInt, "") + + marshal := func(i interface{}) ([]byte, error) { return gocql.Marshal(tType, i) } + unmarshal := func(bytes []byte, i interface{}) error { + return gocql.Unmarshal(tType, bytes, i) + } + + // unmarshal `custom string` unsupported + brokenCustomStrings := utils.GetTypes(mod.String(""), (*mod.String)(nil)) + + // marshal "" (empty string) unsupported + // unmarshal nil value into (string)("0") + brokenEmptyStrings := utils.GetTypes(string(""), mod.String("")) + + // marshal `custom string` unsupported + // marshal `big.Int` unsupported + brokenMarshalTypes := append(brokenCustomStrings, utils.GetTypes(big.Int{}, &big.Int{})...) + + // marshal data, which equal math.MaxUint64, into uint and uit64 leads to an error + brokenUints := utils.GetTypes(uint(0), mod.Uint64(0), mod.Uint(0), (*uint)(nil), (*mod.Uint64)(nil), (*mod.Uint)(nil)) + + serialization.Set{ + Data: nil, + Values: mod.Values{ + (*int8)(nil), (*int16)(nil), (*int32)(nil), (*int64)(nil), (*int)(nil), + (*uint8)(nil), (*uint16)(nil), (*uint32)(nil), (*uint64)(nil), (*uint)(nil), + (*string)(nil), (*big.Int)(nil), "", + }.AddVariants(mod.CustomType), + BrokenMarshalTypes: brokenEmptyStrings, + BrokenUnmarshalTypes: brokenEmptyStrings, + }.Run("[nil]nullable", t, marshal, unmarshal) + + serialization.Set{ + Data: nil, + Values: mod.Values{ + int8(0), int16(0), int32(0), int64(0), int(0), + uint8(0), uint16(0), uint32(0), uint64(0), uint(0), + "0", big.Int{}, + }.AddVariants(mod.CustomType), + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("[nil]unmarshal", t, nil, unmarshal) + + serialization.Set{ + Data: make([]byte, 0), + Values: mod.Values{ + int8(0), int16(0), int32(0), int64(0), int(0), + uint8(0), uint16(0), uint32(0), uint64(0), uint(0), + "0", *big.NewInt(0), + }.AddVariants(mod.All...), + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("[]unmarshal", t, nil, unmarshal) + + serialization.Set{ + Data: []byte("\x00\x00\x00\x00\x00\x00\x00\x00"), + Values: mod.Values{ + int8(0), int16(0), int32(0), int64(0), int(0), + uint8(0), uint16(0), uint32(0), uint64(0), uint(0), + "0", *big.NewInt(0), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenMarshalTypes, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("zeros", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x7f\xff\xff\xff\xff\xff\xff\xff"), + Values: mod.Values{ + int64(9223372036854775807), int(9223372036854775807), + "9223372036854775807", *big.NewInt(9223372036854775807), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenCustomStrings, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("max", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x80\x00\x00\x00\x00\x00\x00\x00"), + Values: mod.Values{ + int64(-9223372036854775808), int(-9223372036854775808), + "-9223372036854775808", *big.NewInt(-9223372036854775808), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenCustomStrings, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("min", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x00\x00\x00\x00\x7f\xff\xff\xff"), + Values: mod.Values{ + int32(2147483647), int64(2147483647), int(2147483647), + "2147483647", *big.NewInt(2147483647), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenMarshalTypes, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("2147483647", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\xff\xff\xff\xff\x80\x00\x00\x00"), + Values: mod.Values{ + int32(-2147483648), int64(-2147483648), int(-2147483648), + "-2147483648", *big.NewInt(-2147483648), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenMarshalTypes, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("-2147483648", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x00\x00\x00\x00\x00\x00\x7f\xff"), + Values: mod.Values{ + int16(32767), int32(32767), int64(32767), int(32767), + "32767", *big.NewInt(32767), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenMarshalTypes, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("32767", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\xff\xff\xff\xff\xff\xff\x80\x00"), + Values: mod.Values{ + int16(-32768), int32(-32768), int64(-32768), int(-32768), + "-32768", *big.NewInt(-32768), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenMarshalTypes, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("-32768", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x00\x00\x00\x00\x00\x00\x00\x7f"), + Values: mod.Values{ + int8(127), int16(127), int32(127), int64(127), int(127), + "127", *big.NewInt(127), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenMarshalTypes, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("127", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\xff\xff\xff\xff\xff\xff\xff\x80"), + Values: mod.Values{ + int8(-128), int16(-128), int32(-128), int64(-128), int(-128), + "-128", *big.NewInt(-128), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenMarshalTypes, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("-128", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x00\x00\x00\x00\x00\x00\x00\xff"), + Values: mod.Values{ + uint8(255), uint16(255), uint32(255), uint64(255), uint(255), + }.AddVariants(mod.All...), + }.Run("255", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x00\x00\x00\x00\x00\x00\xff\xff"), + Values: mod.Values{ + uint16(65535), uint32(65535), uint64(65535), uint(65535), + }.AddVariants(mod.All...), + }.Run("65535", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x00\x00\x00\x00\xff\xff\xff\xff"), + Values: mod.Values{ + uint32(4294967295), uint64(4294967295), uint(4294967295), + }.AddVariants(mod.All...), + }.Run("4294967295", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\xff\xff\xff\xff\xff\xff\xff\xff"), + Values: mod.Values{ + uint64(18446744073709551615), uint(18446744073709551615), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenUints, + }.Run("max_uint", t, marshal, unmarshal) +} From e6dc3c2df4cadeca41c3cce044dd073c15c8b127 Mon Sep 17 00:00:00 2001 From: illia-li Date: Fri, 27 Sep 2024 13:40:43 -0400 Subject: [PATCH 6/7] add counter test --- marshal_6_counter_test.go | 185 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 185 insertions(+) create mode 100644 marshal_6_counter_test.go diff --git a/marshal_6_counter_test.go b/marshal_6_counter_test.go new file mode 100644 index 00000000..1e9a5ad9 --- /dev/null +++ b/marshal_6_counter_test.go @@ -0,0 +1,185 @@ +package gocql_test + +import ( + "math/big" + "testing" + + "github.com/gocql/gocql" + "github.com/gocql/gocql/internal/tests/utils" + "github.com/gocql/gocql/marshal/tests/mod" + "github.com/gocql/gocql/marshal/tests/serialization" +) + +func TestMarshalCounter(t *testing.T) { + tType := gocql.NewNativeType(4, gocql.TypeCounter, "") + + marshal := func(i interface{}) ([]byte, error) { return gocql.Marshal(tType, i) } + unmarshal := func(bytes []byte, i interface{}) error { + return gocql.Unmarshal(tType, bytes, i) + } + + // unmarshal `custom string` unsupported + brokenCustomStrings := utils.GetTypes(mod.String(""), (*mod.String)(nil)) + + // marshal "" (empty string) unsupported + // unmarshal nil value into (string)("0") + brokenEmptyStrings := utils.GetTypes(string(""), mod.String("")) + + // marshal `custom string` unsupported + // marshal `big.Int` unsupported + brokenMarshalTypes := append(brokenCustomStrings, utils.GetTypes(big.Int{}, &big.Int{})...) + + // marshal data, which equal math.MaxUint64, into uint and uit64 leads to an error + brokenUints := utils.GetTypes(uint(0), mod.Uint64(0), mod.Uint(0), (*uint)(nil), (*mod.Uint64)(nil), (*mod.Uint)(nil)) + + serialization.Set{ + Data: nil, + Values: mod.Values{ + (*int8)(nil), (*int16)(nil), (*int32)(nil), (*int64)(nil), (*int)(nil), + (*uint8)(nil), (*uint16)(nil), (*uint32)(nil), (*uint64)(nil), (*uint)(nil), + (*string)(nil), (*big.Int)(nil), "", + }.AddVariants(mod.CustomType), + BrokenMarshalTypes: brokenEmptyStrings, + BrokenUnmarshalTypes: brokenEmptyStrings, + }.Run("[nil]nullable", t, marshal, unmarshal) + + serialization.Set{ + Data: nil, + Values: mod.Values{ + int8(0), int16(0), int32(0), int64(0), int(0), + uint8(0), uint16(0), uint32(0), uint64(0), uint(0), + "0", big.Int{}, + }.AddVariants(mod.CustomType), + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("[nil]unmarshal", t, nil, unmarshal) + + serialization.Set{ + Data: make([]byte, 0), + Values: mod.Values{ + int8(0), int16(0), int32(0), int64(0), int(0), + uint8(0), uint16(0), uint32(0), uint64(0), uint(0), + "0", *big.NewInt(0), + }.AddVariants(mod.All...), + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("[]unmarshal", t, nil, unmarshal) + + serialization.Set{ + Data: []byte("\x00\x00\x00\x00\x00\x00\x00\x00"), + Values: mod.Values{ + int8(0), int16(0), int32(0), int64(0), int(0), + uint8(0), uint16(0), uint32(0), uint64(0), uint(0), + "0", *big.NewInt(0), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenMarshalTypes, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("zeros", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x7f\xff\xff\xff\xff\xff\xff\xff"), + Values: mod.Values{ + int64(9223372036854775807), int(9223372036854775807), + "9223372036854775807", *big.NewInt(9223372036854775807), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenCustomStrings, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("max", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x80\x00\x00\x00\x00\x00\x00\x00"), + Values: mod.Values{ + int64(-9223372036854775808), int(-9223372036854775808), + "-9223372036854775808", *big.NewInt(-9223372036854775808), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenCustomStrings, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("min", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x00\x00\x00\x00\x7f\xff\xff\xff"), + Values: mod.Values{ + int32(2147483647), int64(2147483647), int(2147483647), + "2147483647", *big.NewInt(2147483647), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenMarshalTypes, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("2147483647", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\xff\xff\xff\xff\x80\x00\x00\x00"), + Values: mod.Values{ + int32(-2147483648), int64(-2147483648), int(-2147483648), + "-2147483648", *big.NewInt(-2147483648), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenMarshalTypes, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("-2147483648", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x00\x00\x00\x00\x00\x00\x7f\xff"), + Values: mod.Values{ + int16(32767), int32(32767), int64(32767), int(32767), + "32767", *big.NewInt(32767), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenMarshalTypes, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("32767", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\xff\xff\xff\xff\xff\xff\x80\x00"), + Values: mod.Values{ + int16(-32768), int32(-32768), int64(-32768), int(-32768), + "-32768", *big.NewInt(-32768), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenMarshalTypes, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("-32768", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x00\x00\x00\x00\x00\x00\x00\x7f"), + Values: mod.Values{ + int8(127), int16(127), int32(127), int64(127), int(127), + "127", *big.NewInt(127), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenMarshalTypes, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("127", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\xff\xff\xff\xff\xff\xff\xff\x80"), + Values: mod.Values{ + int8(-128), int16(-128), int32(-128), int64(-128), int(-128), + "-128", *big.NewInt(-128), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenMarshalTypes, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("-128", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x00\x00\x00\x00\x00\x00\x00\xff"), + Values: mod.Values{ + uint8(255), uint16(255), uint32(255), uint64(255), uint(255), + }.AddVariants(mod.All...), + }.Run("255", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x00\x00\x00\x00\x00\x00\xff\xff"), + Values: mod.Values{ + uint16(65535), uint32(65535), uint64(65535), uint(65535), + }.AddVariants(mod.All...), + }.Run("65535", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x00\x00\x00\x00\xff\xff\xff\xff"), + Values: mod.Values{ + uint32(4294967295), uint64(4294967295), uint(4294967295), + }.AddVariants(mod.All...), + }.Run("4294967295", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\xff\xff\xff\xff\xff\xff\xff\xff"), + Values: mod.Values{ + uint64(18446744073709551615), uint(18446744073709551615), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenUints, + }.Run("max_uint", t, marshal, unmarshal) +} From ca951562f84cda47ada374be24f5fc43386f6730 Mon Sep 17 00:00:00 2001 From: illia-li Date: Fri, 27 Sep 2024 13:40:57 -0400 Subject: [PATCH 7/7] add varint test --- marshal_7_varint_test.go | 203 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 203 insertions(+) create mode 100644 marshal_7_varint_test.go diff --git a/marshal_7_varint_test.go b/marshal_7_varint_test.go new file mode 100644 index 00000000..e99ae0d7 --- /dev/null +++ b/marshal_7_varint_test.go @@ -0,0 +1,203 @@ +package gocql_test + +import ( + "math/big" + "testing" + + "github.com/gocql/gocql" + "github.com/gocql/gocql/internal/tests/utils" + "github.com/gocql/gocql/marshal/tests/mod" + "github.com/gocql/gocql/marshal/tests/serialization" +) + +func TestMarshalVarInt(t *testing.T) { + tType := gocql.NewNativeType(4, gocql.TypeVarint, "") + + marshal := func(i interface{}) ([]byte, error) { return gocql.Marshal(tType, i) } + unmarshal := func(bytes []byte, i interface{}) error { + return gocql.Unmarshal(tType, bytes, i) + } + + // unmarshal `custom string` unsupported + brokenCustomStrings := utils.GetTypes(mod.String(""), (*mod.String)(nil)) + + // marshal "" (empty string) unsupported + // unmarshal nil value into (string)("0") + brokenEmptyStrings := utils.GetTypes(string(""), mod.String("")) + + // marshal data, which equal math.MaxUint64, into uint and uit64 leads to an error + brokenUints := utils.GetTypes(uint(0), mod.Uint64(0), mod.Uint(0), (*uint)(nil), (*mod.Uint64)(nil), (*mod.Uint)(nil)) + + // marshal and unmarshal all strings with data or value which out of range of int64 unsupported + brokenBigStrings := utils.GetTypes(string(""), (*string)(nil), mod.String(""), (*mod.String)(nil)) + + serialization.Set{ + Data: nil, + Values: mod.Values{ + (*int8)(nil), (*int16)(nil), (*int32)(nil), (*int64)(nil), (*int)(nil), + (*uint8)(nil), (*uint16)(nil), (*uint32)(nil), (*uint64)(nil), (*uint)(nil), + (*string)(nil), (*big.Int)(nil), "", + }.AddVariants(mod.CustomType), + BrokenMarshalTypes: brokenEmptyStrings, + BrokenUnmarshalTypes: brokenEmptyStrings, + }.Run("[nil]nullable", t, marshal, unmarshal) + + serialization.Set{ + Data: nil, + Values: mod.Values{ + int8(0), int16(0), int32(0), int64(0), int(0), + uint8(0), uint16(0), uint32(0), uint64(0), uint(0), + "0", big.Int{}, + }.AddVariants(mod.CustomType), + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("[nil]unmarshal", t, nil, unmarshal) + + serialization.Set{ + Data: make([]byte, 0), + Values: mod.Values{ + int8(0), int16(0), int32(0), int64(0), int(0), + uint8(0), uint16(0), uint32(0), uint64(0), uint(0), + "0", *big.NewInt(0), + }.AddVariants(mod.All...), + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("[]unmarshal", t, nil, unmarshal) + + serialization.Set{ + Data: []byte("\x00"), + Values: mod.Values{ + int8(0), int16(0), int32(0), int64(0), int(0), + uint8(0), uint16(0), uint32(0), uint64(0), uint(0), + "0", *big.NewInt(0), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenCustomStrings, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("zeros", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x7f\xff\xff\xff\xff\xff\xff\xff"), + Values: mod.Values{ + int64(9223372036854775807), int(9223372036854775807), + "9223372036854775807", *big.NewInt(9223372036854775807), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenCustomStrings, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("maxInt64", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x80\x00\x00\x00\x00\x00\x00\x00"), + Values: mod.Values{ + int64(-9223372036854775808), int(-9223372036854775808), + "-9223372036854775808", *big.NewInt(-9223372036854775808), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenCustomStrings, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("minInt64", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x7f\xff\xff\xff"), + Values: mod.Values{ + int32(2147483647), int64(2147483647), int(2147483647), + "2147483647", *big.NewInt(2147483647), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenCustomStrings, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("2147483647", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x80\x00\x00\x00"), + Values: mod.Values{ + int32(-2147483648), int64(-2147483648), int(-2147483648), + "-2147483648", *big.NewInt(-2147483648), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenCustomStrings, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("-2147483648", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x7f\xff"), + Values: mod.Values{ + int16(32767), int32(32767), int64(32767), int(32767), + "32767", *big.NewInt(32767), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenCustomStrings, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("32767", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x80\x00"), + Values: mod.Values{ + int16(-32768), int32(-32768), int64(-32768), int(-32768), + "-32768", *big.NewInt(-32768), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenCustomStrings, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("-32768", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x7f"), + Values: mod.Values{ + int8(127), int16(127), int32(127), int64(127), int(127), + "127", *big.NewInt(127), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenCustomStrings, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("127", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x80"), + Values: mod.Values{ + int8(-128), int16(-128), int32(-128), int64(-128), int(-128), + "-128", *big.NewInt(-128), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenCustomStrings, + BrokenUnmarshalTypes: brokenCustomStrings, + }.Run("-128", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x00\xff"), + Values: mod.Values{ + uint8(255), uint16(255), uint32(255), uint64(255), uint(255), + }.AddVariants(mod.All...), + }.Run("255", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x00\xff\xff"), + Values: mod.Values{ + uint16(65535), uint32(65535), uint64(65535), uint(65535), + }.AddVariants(mod.All...), + }.Run("65535", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x00\xff\xff\xff\xff"), + Values: mod.Values{ + uint32(4294967295), uint64(4294967295), uint(4294967295), + }.AddVariants(mod.All...), + }.Run("4294967295", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x00\xff\xff\xff\xff\xff\xff\xff\xff"), + Values: mod.Values{ + uint64(18446744073709551615), uint(18446744073709551615), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenUints, + BrokenUnmarshalTypes: brokenUints, + }.Run("max_uint", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\x00\x80\x00\x00\x00\x00\x00\x00\x00"), + Values: mod.Values{ + "9223372036854775808", *big.NewInt(0).Add(big.NewInt(1), big.NewInt(9223372036854775807)), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenBigStrings, + BrokenUnmarshalTypes: brokenBigStrings, + }.Run("maxInt64+1", t, marshal, unmarshal) + + serialization.Set{ + Data: []byte("\xff\x7f\xff\xff\xff\xff\xff\xff\xff"), + Values: mod.Values{ + "-9223372036854775809", *big.NewInt(0).Add(big.NewInt(-1), big.NewInt(-9223372036854775808)), + }.AddVariants(mod.All...), + BrokenMarshalTypes: brokenBigStrings, + BrokenUnmarshalTypes: brokenBigStrings, + }.Run("minInt64-1", t, marshal, unmarshal) +}