func (u *user) UnmarshalBinary(data []byte) error {
dec := encdec.NewDec(data)
u.name = string(dec.ByteSlice())
u.age = int(dec.Int64())
dec.Unmarshaler(&u.registered)
return dec.Error()
}
func (t *fuzzTestType) UnmarshalBinary(data []byte) error {
unmErr := errors.New("unmarshal error")
dec := encdec.NewDec(data)
t.a = dec.Uint64()
if t.a != dec.Uint64() {
return unmErr
}
t.b = dec.Int64()
if t.b != dec.Int64() {
return unmErr
}
t.c = dec.Float64()
if t.c != dec.Float64() {
return unmErr
}
t.d = dec.ByteSlice()
if !bytes.Equal(t.d, dec.ByteSlice()) {
return unmErr
}
dec.Unmarshaler(&t.e)
var et time.Time
dec.Unmarshaler(&et)
if !t.e.Equal(et) {
return unmErr
}
return dec.Error()
}
func (h *head) UnmarshalBinary(data []byte) error {
dec := encdec.NewDec(data)
h.offset = dec.Int64()
// h.entityDesc = dec.ByteSlice()
h.bodyLen = int(dec.Uint64())
// h.eID = data[:dec.Pos()]
return dec.Error()
}
func (e *Entity) decompileHead(d []byte) error {
// if e.h == nil {
// e.h = &head{}
// }
dec := encdec.NewDec(d)
dec.Unmarshaler(&e.h)
e.h.entityID = d[:dec.Pos()]
return dec.Error()
}
func (e *Entity) decompileBody(d []byte) error {
dec := encdec.NewDec(d)
dec.ByteSlice() //skip header
e.Body = dec.ByteSlice()
l := int(dec.Uint64())
e.Tags = make([]Tag, l)
for j := 0; j < l; j++ {
e.Tags[j] = Tag(dec.ByteSlice())
}
return dec.Error()
}
func (gs granularStorage) get(i int) ([]byte, error) {
if i < 0 || i >= gs.len() {
return nil, ErrIndexOutOfRange
}
p := i * gs.granularity
lb := make([]byte, 8)
n, err := gs.data.ReadAt(lb, int64(p))
if err != nil {
return nil, err
}
if n != len(lb) {
return nil, errStorage
}
dec := encdec.NewDec(lb)
ln := int(dec.Uint64())
b := make([]byte, ln+dec.Pos())
n, err = gs.data.ReadAt(b, int64(p))
if err != nil {
return nil, err
}
if n != len(b) {
return nil, errStorage
}
// fmt.Printf("get: %v %v \n", i, b)
dec = encdec.NewDec(b)
nb := dec.ByteSlice()
if dec.Error() != nil {
return nil, dec.Error()
}
if nb[0] == delcom[0] && nb[1] == delcom[1] && nb[2] == delcom[2] && nb[3] == delcom[3] && nb[4] == delcom[4] && nb[5] == delcom[5] {
return nil, errDeleted
}
return nb, nil
}
func Fuzz(data []byte) int {
var v fuzzTestType
dec := encdec.NewDec(data)
dec.Unmarshaler(&v)
if dec.Error() != nil {
return 0
}
enc := encdec.NewEnc()
enc.Marshaler(&v)
if enc.Error() != nil {
panic(enc.Error())
}
var v1 fuzzTestType
dec = encdec.NewDec(enc.Bytes())
dec.Unmarshaler(&v1)
if dec.Error() != nil {
panic(dec.Error())
}
if !reflect.DeepEqual(v, v1) {
panic("not equal")
}
return 1
}
func TestFuzzCrashers(t *testing.T) {
var v fuzzTestType
var crashers = [][]byte{
[]byte("\x00\f\xeb\xe4\xcb\xee\xff\xf7\xff\xfd\xff\x0100"),
[]byte("\x14\x00\x12\xfb\xff\xff\xff\xff\xff\xff\xff\u007f000000000"),
[]byte("\x00\x12\xfe\xff\xff\xff\xff\xff\xff\xff\u007f000000000"),
[]byte("\x03\x0100")}
for _, c := range crashers {
dec := encdec.NewDec(c)
dec.Unmarshaler(&v)
}
// var errors = [][]byte{
// []byte("\x02\xb6\x01\t000000000\t000000000\t000000000\t000000000\n0000000000\n0000000000\x010W\x02000000000000000000000000000000000000000000000000000" +
// "00000000000000000000000000000000000\x000\n0000000000\x01\x0f\x0100000000000000")}
// for _, e := range errors {
// dec := encdec.NewDec(e)
// dec.Unmarshaler(&v)
// if dec.Error() != nil {
// panic(dec.Error())
// }
// enc := encdec.NewEnc()
// enc.Marshaler(&v)
// if enc.Error() != nil {
// panic(enc.Error())
// }
// fmt.Printf("%v\n%v\n%v\n", e, v, enc.Bytes())
// var v1 fuzzTestType
// dec = encdec.NewDec(enc.Bytes())
// dec.Unmarshaler(&v1)
// if dec.Error() != nil {
// panic(dec.Error())
// }
// if !reflect.DeepEqual(v, v1) {
// panic("not equal")
// }
// }
}
func Example() {
//encode data to byte slice
enc := encdec.NewEnc()
enc.Uint64(uint64(len(users)))
for _, u := range users {
enc.Marshaler(&u)
}
if enc.Error() != nil {
panic(enc.Error())
}
slice := enc.Bytes()
//decode data from byte slice
dec := encdec.NewDec(slice)
l := int(dec.Uint64())
users = make([]user, l)
for i := 0; i < l; i++ {
dec.Unmarshaler(&users[i])
}
if dec.Error() != nil {
panic(dec.Error())
}
}