Hello guys,
I'm trying to use encoding/gob package to know how it works.
And I wrote below codes.
import "encoding/gob"
func ToGOB64(data interface{}) (string, error) {
b := bytes.Buffer{}
e := gob.NewEncoder(&b)
err := e.Encode(data)
if err != nil {
fmt.Println(`failed gob Encode`, err)
return "", err
}
return base64.StdEncoding.EncodeToString(b.Bytes()), nil
}
func FromGOB64(str string, tData interface{}) error {
by, err := base64.StdEncoding.DecodeString(str)
if err != nil {
return err
}
b := bytes.Buffer{}
b.Write(by)
d := gob.NewDecoder(&b)
err = d.Decode(tData)
if err != nil {
return err
}
return nil
}
And then, I prepared for test targeted type are struct, map, interface{}.
func TestSerializeStruct(t *testing.T) {
u := User{Id: 10, Name: "harry dayo"}
result, err := ToGOB64(u)
if err != nil {
t.Errorf("TestSerializeStruct error: %s", err)
}
if result !=
"Iv+BAwEBBFVzZXIB/4IAAQIBAklkAQQAAQROYW1lAQwAAAAR/4IBFAEKaGFycnkgZGF5bwA=" {
t.Errorf("TestSerializeStruct result: %+v", result)
}
}
func TestDeSerializeStruct(t *testing.T) {
u := User{}
err := FromGOB64(
"Iv+BAwEBBFVzZXIB/4IAAQIBAklkAQQAAQROYW1lAQwAAAAR/4IBFAEKaGFycnkgZGF5bwA=",
&u)
if err != nil {
t.Errorf("TestDeSerializeStruct error: %s", err)
}
if u.Id != 10 {
t.Errorf("TestDeSerializeStruct result: %+v", u)
}
}
//2.map (map is not stable.)
func TestSerializeMap(t *testing.T) {
m := map[string]int{"apple": 150, "banana": 300, "lemon": 300}
//when using map, result is not stable.
result, err := ToGOB64(m)
if err != nil {
t.Errorf("TestSerializeMap error: %s", err)
}
if result !=
"Dv+DBAEC/4QAAQwBBAAAIP+EAAMFYXBwbGX+ASwGYmFuYW5h/gJYBWxlbW9u/gJY" {
//if result !=
"Dv+DBAEC/4QAAQwBBAAAIP+EAAMGYmFuYW5h/gJYBWxlbW9u/gJYBWFwcGxl/gEs" {
t.Errorf("TestSerializeMap result: %#v", result)
}
}
//
func TestDeSerializeMap(t *testing.T) {
u := map[string]int{}
//FromGOB64("Dv+DBAEC/4QAAQwBBAAAIP+EAAMFYXBwbGX+ASwGYmFuYW5h/gJYBWxlbW9u/gJY",
&u)
err := FromGOB64(
"Dv+DBAEC/4QAAQwBBAAAIP+EAAMGYmFuYW5h/gJYBWxlbW9u/gJYBWFwcGxl/gEs", &u)
if err != nil {
t.Errorf("TestDeSerializeMap error: %s", err)
}
if u["apple"] != 150 {
t.Errorf("TestDeSerializeMap result: %#v", u)
}
}
//interface x slice
func TestSerializeInterfaces(t *testing.T) {
args := []interface{}{1, "abcde", true}
result, err := ToGOB64(args)
if err != nil {
t.Errorf("TestSerializeInterfaces error: %s", err)
}
if result !=
"DP+BAgEC/4IAARAAACX/ggADA2ludAQCAAIGc3RyaW5nDAcABWFiY2RlBGJvb2wCAgAB" {
t.Errorf("TestSerializeInterfaces result: %+v", result)
}
}
func TestDeSerializeInterfaces(t *testing.T) {
args := []interface{}{}
err := FromGOB64(
"DP+BAgEC/4IAARAAACX/ggADA2ludAQCAAIGc3RyaW5nDAcABWFiY2RlBGJvb2wCAgAB", &
args)
if err != nil {
t.Errorf("TestDeSerializeInterfaces error: %s", err)
}
if args[0] != 1 || args[1] != "abcde" || args[2] != true {
t.Errorf("TestDeSerializeInterfaces result: %+v", args)
}
}
As a result, serialized map value often change though deserialized map is
no problem.
Why serialized value is not invaliable when using map value.
I'd like to know that reason sincerely.
Thanks in advance.
--
You received this message because you are subscribed to the Google Groups
"golang-nuts" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to golang-nuts+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.
