THRIFT-2159 Serializer/Deserializer for Go

Patch: Justin Judd

diff --git a/lib/go/thrift/deserializer.go b/lib/go/thrift/deserializer.go
new file mode 100644 (file)
index 0000000..e7effb1
--- /dev/null
+++ b/lib/go/thrift/deserializer.go
@@ -0,0 +1,39 @@
+package thrift
+
+type TDeserializer struct {
+       Transport TTransport
+       Protocol  TProtocol
+}
+
+func NewTDeserializer() *TDeserializer {
+       var transport TTransport
+       transport = NewTMemoryBufferLen(1024)
+
+       protocol := NewTBinaryProtocolFactoryDefault().GetProtocol(transport)
+
+       return &TDeserializer{
+               transport,
+               protocol}
+}
+
+func (t *TDeserializer) ReadString(msg TStruct, s string) (err error) {
+       err = nil
+       if _, err = t.Transport.Write([]byte(s)); err != nil {
+               return
+       }
+       if err = msg.Read(t.Protocol); err != nil {
+               return
+       }
+       return
+}
+
+func (t *TDeserializer) Read(msg TStruct, b []byte) (err error) {
+       err = nil
+       if _, err = t.Transport.Write(b); err != nil {
+               return
+       }
+       if err = msg.Read(t.Protocol); err != nil {
+               return
+       }
+       return
+}

diff --git a/lib/go/thrift/serializer.go b/lib/go/thrift/serializer.go
new file mode 100644 (file)
index 0000000..bb6a2c8
--- /dev/null
+++ b/lib/go/thrift/serializer.go
@@ -0,0 +1,74 @@
+package thrift
+
+type TSerializer struct {
+       Transport TTransport
+       Protocol  TProtocol
+}
+
+type TStruct interface {
+       Write(p TProtocol) error
+       Read(p TProtocol) error
+}
+
+func NewTSerializer() *TSerializer {
+       var transport TTransport
+       transport = NewTMemoryBufferLen(1024)
+
+       protocol := NewTBinaryProtocolFactoryDefault().GetProtocol(transport)
+
+       return &TSerializer{
+               transport,
+               protocol}
+}
+
+func (t *TSerializer) WriteString(msg TStruct) (s string, err error) {
+       s = ""
+       err = nil
+
+       if err = msg.Write(t.Protocol); err != nil {
+               return
+       }
+
+       if err = t.Protocol.Flush(); err != nil {
+               return
+       }
+       if err = t.Transport.Flush(); err != nil {
+               return
+       }
+
+       var buf []byte
+       var place int
+       buf = make([]byte, 1024)
+       if place, err = t.Transport.Read(buf); err != nil {
+               return
+       }
+
+       s = string(buf[:place])
+       return
+}
+
+func (t *TSerializer) Write(msg TStruct) (b []byte, err error) {
+       err = nil
+
+       if err = msg.Write(t.Protocol); err != nil {
+               return
+       }
+
+       if err = t.Protocol.Flush(); err != nil {
+               return
+       }
+
+       if err = t.Transport.Flush(); err != nil {
+               return
+       }
+
+       var buf []byte
+       var place int
+       buf = make([]byte, 1024)
+       if place, err = t.Transport.Read(buf); err != nil {
+               return
+       }
+
+       b = buf[:place]
+       return
+}

diff --git a/lib/go/thrift/serializer_test.go b/lib/go/thrift/serializer_test.go
new file mode 100644 (file)
index 0000000..840f6f7
--- /dev/null
+++ b/lib/go/thrift/serializer_test.go
@@ -0,0 +1,150 @@
+package thrift
+
+import (
+       "errors"
+       "fmt"
+       "testing"
+)
+
+type ProtocolFactory interface {
+       GetProtocol(t TTransport) TProtocol
+}
+
+func compareStructs(m, m1 TestStruct) (bool, error) {
+       switch {
+       case m.On != m1.On:
+               return false, errors.New("Boolean not equal")
+       case m.B != m1.B:
+               return false, errors.New("Byte not equal")
+       case m.Int16 != m1.Int16:
+               return false, errors.New("Int16 not equal")
+       case m.Int32 != m1.Int32:
+               return false, errors.New("Int32 not equal")
+       case m.Int64 != m1.Int64:
+               return false, errors.New("Int64 not equal")
+       case m.D != m1.D:
+               return false, errors.New("Double not equal")
+       case m.St != m1.St:
+               return false, errors.New("String not equal")
+
+       case len(m.Bin) != len(m1.Bin):
+               return false, errors.New("Binary size not equal")
+       case len(m.Bin) == len(m1.Bin):
+               for i := range m.Bin {
+                       if m.Bin[i] != m1.Bin[i] {
+                               return false, errors.New("Binary not equal")
+                       }
+               }
+       case len(m.StringMap) != len(m1.StringMap):
+               return false, errors.New("StringMap size not equal")
+       case len(m.StringList) != len(m1.StringList):
+               return false, errors.New("StringList size not equal")
+       case len(m.StringSet) != len(m1.StringSet):
+               return false, errors.New("StringSet size not equal")
+
+       case m.E != m1.E:
+               return false, errors.New("TestEnum not equal")
+
+       default:
+               return true, nil
+
+       }
+       return true, nil
+}
+
+func ProtocolTest1(test *testing.T, pf ProtocolFactory) (bool, error) {
+       t := NewTSerializer()
+       t.Protocol = pf.GetProtocol(t.Transport)
+       var m = TestStruct{}
+       m.On = true
+       m.B = int8(0)
+       m.Int16 = 1
+       m.Int32 = 2
+       m.Int64 = 3
+       m.D = 4.1
+       m.St = "Test"
+       m.Bin = make([]byte, 10)
+       m.StringMap = make(map[string]string, 5)
+       m.StringList = make([]string, 5)
+       m.StringSet = make(map[string]bool, 5)
+       m.E = 2
+
+       s, err := t.WriteString(&m)
+       if err != nil {
+               return false, errors.New(fmt.Sprintf("Unable to Serialize struct\n\t %s", err))
+       }
+
+       t1 := NewTDeserializer()
+       t1.Protocol = pf.GetProtocol(t1.Transport)
+       var m1 = TestStruct{}
+       if err = t1.ReadString(&m1, s); err != nil {
+               return false, errors.New(fmt.Sprintf("Unable to Deserialize struct\n\t %s", err))
+
+       }
+
+       return compareStructs(m, m1)
+
+}
+
+func ProtocolTest2(test *testing.T, pf ProtocolFactory) (bool, error) {
+       t := NewTSerializer()
+       t.Protocol = pf.GetProtocol(t.Transport)
+       var m = TestStruct{}
+       m.On = false
+       m.B = int8(0)
+       m.Int16 = 1
+       m.Int32 = 2
+       m.Int64 = 3
+       m.D = 4.1
+       m.St = "Test"
+       m.Bin = make([]byte, 10)
+       m.StringMap = make(map[string]string, 5)
+       m.StringList = make([]string, 5)
+       m.StringSet = make(map[string]bool, 5)
+       m.E = 2
+
+       s, err := t.WriteString(&m)
+       if err != nil {
+               return false, errors.New(fmt.Sprintf("Unable to Serialize struct\n\t %s", err))
+
+       }
+
+       t1 := NewTDeserializer()
+       t1.Protocol = pf.GetProtocol(t1.Transport)
+       var m1 = TestStruct{}
+       if err = t1.ReadString(&m1, s); err != nil {
+               return false, errors.New(fmt.Sprintf("Unable to Deserialize struct\n\t %s", err))
+
+       }
+
+       return compareStructs(m, m1)
+
+}
+
+func TestSerializer(t *testing.T) {
+
+       var protocol_factories map[string]ProtocolFactory
+       protocol_factories = make(map[string]ProtocolFactory)
+       protocol_factories["Binary"] = NewTBinaryProtocolFactoryDefault()
+       protocol_factories["Compact"] = NewTCompactProtocolFactory()
+       protocol_factories["SimpleJSON"] = NewTSimpleJSONProtocolFactory()
+       protocol_factories["JSON"] = NewTJSONProtocolFactory()
+
+       var tests map[string]func(*testing.T, ProtocolFactory) (bool, error)
+       tests = make(map[string]func(*testing.T, ProtocolFactory) (bool, error))
+       tests["Test 1"] = ProtocolTest1
+       tests["Test 2"] = ProtocolTest2
+       //tests["Test 3"] = ProtocolTest3 // Example of how to add additional tests
+
+       for name, pf := range protocol_factories {
+
+               for test, f := range tests {
+
+                       if s, err := f(t, pf); !s || err != nil {
+                               t.Errorf("%s Failed for %s protocol\n\t %s", test, name, err)
+                       }
+
+               }
+       }
+
+}

diff --git a/lib/go/thrift/serializer_types.go b/lib/go/thrift/serializer_types.go
new file mode 100644 (file)
index 0000000..2ce353b
--- /dev/null
+++ b/lib/go/thrift/serializer_types.go
@@ -0,0 +1,578 @@
+package thrift
+
+// Autogenerated by Thrift Compiler (1.0.0-dev)
+// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+
+/* THE FOLLOWING THRIFT FILE WAS USED TO CREATE THIS
+
+enum TestEnum {
+       FIRST = 1,
+       SECOND = 2,
+       THIRD = 3,
+       FOURTH = 4,
+}
+
+struct TestStruct {
+       1: bool on,
+       2: byte b,
+       3: i16 int16,
+       4: i32 int32,
+       5: i64 int64,
+       6: double d,
+       7: string st,
+       8: binary bin,
+       9: map<string, string> stringMap,
+       10: list<string> stringList,
+       11: set<string> stringSet,
+       12: TestEnum e,
+}
+*/
+
+import (
+       "fmt"
+       "math"
+)
+
+// (needed to ensure safety because of naive import list constrution.)
+var _ = math.MinInt32
+var _ = ZERO
+var _ = fmt.Printf
+
+var GoUnusedProtection__ int
+
+type TestEnum int64
+
+const (
+       TestEnum_FIRST  TestEnum = 1
+       TestEnum_SECOND TestEnum = 2
+       TestEnum_THIRD  TestEnum = 3
+       TestEnum_FOURTH TestEnum = 4
+)
+
+func (p TestEnum) String() string {
+       switch p {
+       case TestEnum_FIRST:
+               return "TestEnum_FIRST"
+       case TestEnum_SECOND:
+               return "TestEnum_SECOND"
+       case TestEnum_THIRD:
+               return "TestEnum_THIRD"
+       case TestEnum_FOURTH:
+               return "TestEnum_FOURTH"
+       }
+       return "<UNSET>"
+}
+
+func TestEnumFromString(s string) (TestEnum, error) {
+       switch s {
+       case "TestEnum_FIRST":
+               return TestEnum_FIRST, nil
+       case "TestEnum_SECOND":
+               return TestEnum_SECOND, nil
+       case "TestEnum_THIRD":
+               return TestEnum_THIRD, nil
+       case "TestEnum_FOURTH":
+               return TestEnum_FOURTH, nil
+       }
+       return TestEnum(math.MinInt32 - 1), fmt.Errorf("not a valid TestEnum string")
+}
+
+type TestStruct struct {
+       On         bool              `thrift:"on,1"`
+       B          int8              `thrift:"b,2"`
+       Int16      int16             `thrift:"int16,3"`
+       Int32      int32             `thrift:"int32,4"`
+       Int64      int64             `thrift:"int64,5"`
+       D          float64           `thrift:"d,6"`
+       St         string            `thrift:"st,7"`
+       Bin        []byte            `thrift:"bin,8"`
+       StringMap  map[string]string `thrift:"stringMap,9"`
+       StringList []string          `thrift:"stringList,10"`
+       StringSet  map[string]bool   `thrift:"stringSet,11"`
+       E          TestEnum          `thrift:"e,12"`
+}
+
+func NewTestStruct() *TestStruct {
+       return &TestStruct{
+               E: math.MinInt32 - 1, // unset sentinal value
+       }
+}
+
+func (p *TestStruct) IsSetE() bool {
+       return int64(p.E) != math.MinInt32-1
+}
+
+func (p *TestStruct) Read(iprot TProtocol) error {
+       if _, err := iprot.ReadStructBegin(); err != nil {
+               return fmt.Errorf("%T read error %s", p, err)
+       }
+       for {
+               _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
+               if err != nil {
+                       return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
+               }
+               if fieldTypeId == STOP {
+                       break
+               }
+               switch fieldId {
+               case 1:
+                       if err := p.readField1(iprot); err != nil {
+                               return err
+                       }
+               case 2:
+                       if err := p.readField2(iprot); err != nil {
+                               return err
+                       }
+               case 3:
+                       if err := p.readField3(iprot); err != nil {
+                               return err
+                       }
+               case 4:
+                       if err := p.readField4(iprot); err != nil {
+                               return err
+                       }
+               case 5:
+                       if err := p.readField5(iprot); err != nil {
+                               return err
+                       }
+               case 6:
+                       if err := p.readField6(iprot); err != nil {
+                               return err
+                       }
+               case 7:
+                       if err := p.readField7(iprot); err != nil {
+                               return err
+                       }
+               case 8:
+                       if err := p.readField8(iprot); err != nil {
+                               return err
+                       }
+               case 9:
+                       if err := p.readField9(iprot); err != nil {
+                               return err
+                       }
+               case 10:
+                       if err := p.readField10(iprot); err != nil {
+                               return err
+                       }
+               case 11:
+                       if err := p.readField11(iprot); err != nil {
+                               return err
+                       }
+               case 12:
+                       if err := p.readField12(iprot); err != nil {
+                               return err
+                       }
+               default:
+                       if err := iprot.Skip(fieldTypeId); err != nil {
+                               return err
+                       }
+               }
+               if err := iprot.ReadFieldEnd(); err != nil {
+                       return err
+               }
+       }
+       if err := iprot.ReadStructEnd(); err != nil {
+               return fmt.Errorf("%T read struct end error: %s", p, err)
+       }
+       return nil
+}
+
+func (p *TestStruct) readField1(iprot TProtocol) error {
+       if v, err := iprot.ReadBool(); err != nil {
+               return fmt.Errorf("error reading field 1: %s")
+       } else {
+               p.On = v
+       }
+       return nil
+}
+
+func (p *TestStruct) readField2(iprot TProtocol) error {
+       if v, err := iprot.ReadByte(); err != nil {
+               return fmt.Errorf("error reading field 2: %s")
+       } else {
+               p.B = int8(v)
+       }
+       return nil
+}
+
+func (p *TestStruct) readField3(iprot TProtocol) error {
+       if v, err := iprot.ReadI16(); err != nil {
+               return fmt.Errorf("error reading field 3: %s")
+       } else {
+               p.Int16 = v
+       }
+       return nil
+}
+
+func (p *TestStruct) readField4(iprot TProtocol) error {
+       if v, err := iprot.ReadI32(); err != nil {
+               return fmt.Errorf("error reading field 4: %s")
+       } else {
+               p.Int32 = v
+       }
+       return nil
+}
+
+func (p *TestStruct) readField5(iprot TProtocol) error {
+       if v, err := iprot.ReadI64(); err != nil {
+               return fmt.Errorf("error reading field 5: %s")
+       } else {
+               p.Int64 = v
+       }
+       return nil
+}
+
+func (p *TestStruct) readField6(iprot TProtocol) error {
+       if v, err := iprot.ReadDouble(); err != nil {
+               return fmt.Errorf("error reading field 6: %s")
+       } else {
+               p.D = v
+       }
+       return nil
+}
+
+func (p *TestStruct) readField7(iprot TProtocol) error {
+       if v, err := iprot.ReadString(); err != nil {
+               return fmt.Errorf("error reading field 7: %s")
+       } else {
+               p.St = v
+       }
+       return nil
+}
+
+func (p *TestStruct) readField8(iprot TProtocol) error {
+       if v, err := iprot.ReadBinary(); err != nil {
+               return fmt.Errorf("error reading field 8: %s")
+       } else {
+               p.Bin = v
+       }
+       return nil
+}
+
+func (p *TestStruct) readField9(iprot TProtocol) error {
+       _, _, size, err := iprot.ReadMapBegin()
+       if err != nil {
+               return fmt.Errorf("error reading map begin: %s")
+       }
+       p.StringMap = make(map[string]string, size)
+       for i := 0; i < size; i++ {
+               var _key0 string
+               if v, err := iprot.ReadString(); err != nil {
+                       return fmt.Errorf("error reading field 0: %s")
+               } else {
+                       _key0 = v
+               }
+               var _val1 string
+               if v, err := iprot.ReadString(); err != nil {
+                       return fmt.Errorf("error reading field 0: %s")
+               } else {
+                       _val1 = v
+               }
+               p.StringMap[_key0] = _val1
+       }
+       if err := iprot.ReadMapEnd(); err != nil {
+               return fmt.Errorf("error reading map end: %s")
+       }
+       return nil
+}
+
+func (p *TestStruct) readField10(iprot TProtocol) error {
+       _, size, err := iprot.ReadListBegin()
+       if err != nil {
+               return fmt.Errorf("error reading list being: %s")
+       }
+       p.StringList = make([]string, 0, size)
+       for i := 0; i < size; i++ {
+               var _elem2 string
+               if v, err := iprot.ReadString(); err != nil {
+                       return fmt.Errorf("error reading field 0: %s")
+               } else {
+                       _elem2 = v
+               }
+               p.StringList = append(p.StringList, _elem2)
+       }
+       if err := iprot.ReadListEnd(); err != nil {
+               return fmt.Errorf("error reading list end: %s")
+       }
+       return nil
+}
+
+func (p *TestStruct) readField11(iprot TProtocol) error {
+       _, size, err := iprot.ReadSetBegin()
+       if err != nil {
+               return fmt.Errorf("error reading set being: %s")
+       }
+       p.StringSet = make(map[string]bool, size)
+       for i := 0; i < size; i++ {
+               var _elem3 string
+               if v, err := iprot.ReadString(); err != nil {
+                       return fmt.Errorf("error reading field 0: %s")
+               } else {
+                       _elem3 = v
+               }
+               p.StringSet[_elem3] = true
+       }
+       if err := iprot.ReadSetEnd(); err != nil {
+               return fmt.Errorf("error reading set end: %s")
+       }
+       return nil
+}
+
+func (p *TestStruct) readField12(iprot TProtocol) error {
+       if v, err := iprot.ReadI32(); err != nil {
+               return fmt.Errorf("error reading field 12: %s")
+       } else {
+               p.E = TestEnum(v)
+       }
+       return nil
+}
+
+func (p *TestStruct) Write(oprot TProtocol) error {
+       if err := oprot.WriteStructBegin("TestStruct"); err != nil {
+               return fmt.Errorf("%T write struct begin error: %s", p, err)
+       }
+       if err := p.writeField1(oprot); err != nil {
+               return err
+       }
+       if err := p.writeField2(oprot); err != nil {
+               return err
+       }
+       if err := p.writeField3(oprot); err != nil {
+               return err
+       }
+       if err := p.writeField4(oprot); err != nil {
+               return err
+       }
+       if err := p.writeField5(oprot); err != nil {
+               return err
+       }
+       if err := p.writeField6(oprot); err != nil {
+               return err
+       }
+       if err := p.writeField7(oprot); err != nil {
+               return err
+       }
+       if err := p.writeField8(oprot); err != nil {
+               return err
+       }
+       if err := p.writeField9(oprot); err != nil {
+               return err
+       }
+       if err := p.writeField10(oprot); err != nil {
+               return err
+       }
+       if err := p.writeField11(oprot); err != nil {
+               return err
+       }
+       if err := p.writeField12(oprot); err != nil {
+               return err
+       }
+       if err := oprot.WriteFieldStop(); err != nil {
+               return fmt.Errorf("%T write field stop error: %s", err)
+       }
+       if err := oprot.WriteStructEnd(); err != nil {
+               return fmt.Errorf("%T write struct stop error: %s", err)
+       }
+       return nil
+}
+
+func (p *TestStruct) writeField1(oprot TProtocol) (err error) {
+       if err := oprot.WriteFieldBegin("on", BOOL, 1); err != nil {
+               return fmt.Errorf("%T write field begin error 1:on: %s", p, err)
+       }
+       if err := oprot.WriteBool(bool(p.On)); err != nil {
+               return fmt.Errorf("%T.on (1) field write error: %s", p)
+       }
+       if err := oprot.WriteFieldEnd(); err != nil {
+               return fmt.Errorf("%T write field end error 1:on: %s", p, err)
+       }
+       return err
+}
+
+func (p *TestStruct) writeField2(oprot TProtocol) (err error) {
+       if err := oprot.WriteFieldBegin("b", BYTE, 2); err != nil {
+               return fmt.Errorf("%T write field begin error 2:b: %s", p, err)
+       }
+       if err := oprot.WriteByte(byte(p.B)); err != nil {
+               return fmt.Errorf("%T.b (2) field write error: %s", p)
+       }
+       if err := oprot.WriteFieldEnd(); err != nil {
+               return fmt.Errorf("%T write field end error 2:b: %s", p, err)
+       }
+       return err
+}
+
+func (p *TestStruct) writeField3(oprot TProtocol) (err error) {
+       if err := oprot.WriteFieldBegin("int16", I16, 3); err != nil {
+               return fmt.Errorf("%T write field begin error 3:int16: %s", p, err)
+       }
+       if err := oprot.WriteI16(int16(p.Int16)); err != nil {
+               return fmt.Errorf("%T.int16 (3) field write error: %s", p)
+       }
+       if err := oprot.WriteFieldEnd(); err != nil {
+               return fmt.Errorf("%T write field end error 3:int16: %s", p, err)
+       }
+       return err
+}
+
+func (p *TestStruct) writeField4(oprot TProtocol) (err error) {
+       if err := oprot.WriteFieldBegin("int32", I32, 4); err != nil {
+               return fmt.Errorf("%T write field begin error 4:int32: %s", p, err)
+       }
+       if err := oprot.WriteI32(int32(p.Int32)); err != nil {
+               return fmt.Errorf("%T.int32 (4) field write error: %s", p)
+       }
+       if err := oprot.WriteFieldEnd(); err != nil {
+               return fmt.Errorf("%T write field end error 4:int32: %s", p, err)
+       }
+       return err
+}
+
+func (p *TestStruct) writeField5(oprot TProtocol) (err error) {
+       if err := oprot.WriteFieldBegin("int64", I64, 5); err != nil {
+               return fmt.Errorf("%T write field begin error 5:int64: %s", p, err)
+       }
+       if err := oprot.WriteI64(int64(p.Int64)); err != nil {
+               return fmt.Errorf("%T.int64 (5) field write error: %s", p)
+       }
+       if err := oprot.WriteFieldEnd(); err != nil {
+               return fmt.Errorf("%T write field end error 5:int64: %s", p, err)
+       }
+       return err
+}
+
+func (p *TestStruct) writeField6(oprot TProtocol) (err error) {
+       if err := oprot.WriteFieldBegin("d", DOUBLE, 6); err != nil {
+               return fmt.Errorf("%T write field begin error 6:d: %s", p, err)
+       }
+       if err := oprot.WriteDouble(float64(p.D)); err != nil {
+               return fmt.Errorf("%T.d (6) field write error: %s", p)
+       }
+       if err := oprot.WriteFieldEnd(); err != nil {
+               return fmt.Errorf("%T write field end error 6:d: %s", p, err)
+       }
+       return err
+}
+
+func (p *TestStruct) writeField7(oprot TProtocol) (err error) {
+       if err := oprot.WriteFieldBegin("st", STRING, 7); err != nil {
+               return fmt.Errorf("%T write field begin error 7:st: %s", p, err)
+       }
+       if err := oprot.WriteString(string(p.St)); err != nil {
+               return fmt.Errorf("%T.st (7) field write error: %s", p)
+       }
+       if err := oprot.WriteFieldEnd(); err != nil {
+               return fmt.Errorf("%T write field end error 7:st: %s", p, err)
+       }
+       return err
+}
+
+func (p *TestStruct) writeField8(oprot TProtocol) (err error) {
+       if p.Bin != nil {
+               if err := oprot.WriteFieldBegin("bin", BINARY, 8); err != nil {
+                       return fmt.Errorf("%T write field begin error 8:bin: %s", p, err)
+               }
+               if err := oprot.WriteBinary(p.Bin); err != nil {
+                       return fmt.Errorf("%T.bin (8) field write error: %s", p)
+               }
+               if err := oprot.WriteFieldEnd(); err != nil {
+                       return fmt.Errorf("%T write field end error 8:bin: %s", p, err)
+               }
+       }
+       return err
+}
+
+func (p *TestStruct) writeField9(oprot TProtocol) (err error) {
+       if p.StringMap != nil {
+               if err := oprot.WriteFieldBegin("stringMap", MAP, 9); err != nil {
+                       return fmt.Errorf("%T write field begin error 9:stringMap: %s", p, err)
+               }
+               if err := oprot.WriteMapBegin(STRING, STRING, len(p.StringMap)); err != nil {
+                       return fmt.Errorf("error writing map begin: %s")
+               }
+               for k, v := range p.StringMap {
+                       if err := oprot.WriteString(string(k)); err != nil {
+                               return fmt.Errorf("%T. (0) field write error: %s", p)
+                       }
+                       if err := oprot.WriteString(string(v)); err != nil {
+                               return fmt.Errorf("%T. (0) field write error: %s", p)
+                       }
+               }
+               if err := oprot.WriteMapEnd(); err != nil {
+                       return fmt.Errorf("error writing map end: %s")
+               }
+               if err := oprot.WriteFieldEnd(); err != nil {
+                       return fmt.Errorf("%T write field end error 9:stringMap: %s", p, err)
+               }
+       }
+       return err
+}
+
+func (p *TestStruct) writeField10(oprot TProtocol) (err error) {
+       if p.StringList != nil {
+               if err := oprot.WriteFieldBegin("stringList", LIST, 10); err != nil {
+                       return fmt.Errorf("%T write field begin error 10:stringList: %s", p, err)
+               }
+               if err := oprot.WriteListBegin(STRING, len(p.StringList)); err != nil {
+                       return fmt.Errorf("error writing list begin: %s")
+               }
+               for _, v := range p.StringList {
+                       if err := oprot.WriteString(string(v)); err != nil {
+                               return fmt.Errorf("%T. (0) field write error: %s", p)
+                       }
+               }
+               if err := oprot.WriteListEnd(); err != nil {
+                       return fmt.Errorf("error writing list end: %s")
+               }
+               if err := oprot.WriteFieldEnd(); err != nil {
+                       return fmt.Errorf("%T write field end error 10:stringList: %s", p, err)
+               }
+       }
+       return err
+}
+
+func (p *TestStruct) writeField11(oprot TProtocol) (err error) {
+       if p.StringSet != nil {
+               if err := oprot.WriteFieldBegin("stringSet", SET, 11); err != nil {
+                       return fmt.Errorf("%T write field begin error 11:stringSet: %s", p, err)
+               }
+               if err := oprot.WriteSetBegin(STRING, len(p.StringSet)); err != nil {
+                       return fmt.Errorf("error writing set begin: %s")
+               }
+               for v, _ := range p.StringSet {
+                       if err := oprot.WriteString(string(v)); err != nil {
+                               return fmt.Errorf("%T. (0) field write error: %s", p)
+                       }
+               }
+               if err := oprot.WriteSetEnd(); err != nil {
+                       return fmt.Errorf("error writing set end: %s")
+               }
+               if err := oprot.WriteFieldEnd(); err != nil {
+                       return fmt.Errorf("%T write field end error 11:stringSet: %s", p, err)
+               }
+       }
+       return err
+}
+
+func (p *TestStruct) writeField12(oprot TProtocol) (err error) {
+       if p.IsSetE() {
+               if err := oprot.WriteFieldBegin("e", I32, 12); err != nil {
+                       return fmt.Errorf("%T write field begin error 12:e: %s", p, err)
+               }
+               if err := oprot.WriteI32(int32(p.E)); err != nil {
+                       return fmt.Errorf("%T.e (12) field write error: %s", p)
+               }
+               if err := oprot.WriteFieldEnd(); err != nil {
+                       return fmt.Errorf("%T write field end error 12:e: %s", p, err)
+               }
+       }
+       return err
+}
+
+func (p *TestStruct) String() string {
+       if p == nil {
+               return "<nil>"
+       }
+       return fmt.Sprintf("TestStruct(%+v)", *p)
+}