diff --git a/lib/go/thrift/deserializer.go b/lib/go/thrift/deserializer.go
new file mode 100644
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
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
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
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)
+}