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()) } }