diff --git a/lib/go/test/tests/optional_fields_test.go b/lib/go/test/tests/optional_fields_test.go
new file mode 100644
index 0000000..4b0797c
--- /dev/null
+++ b/lib/go/test/tests/optional_fields_test.go
@@ -0,0 +1,280 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package tests
+
+import (
+	"OptionalFieldsTest"
+	"bytes"
+	gomock "code.google.com/p/gomock/gomock"
+	"testing"
+	"thrift"
+)
+
+func TestIsSetReturnFalseOnCreation(t *testing.T) {
+	ao := OptionalFieldsTest.NewAllOptional()
+	if ao.IsSetS() {
+		t.Errorf("Optional field S is set on initialization")
+	}
+	if ao.IsSetI() {
+		t.Errorf("Optional field I is set on initialization")
+	}
+	if ao.IsSetB() {
+		t.Errorf("Optional field B is set on initialization")
+	}
+	if ao.IsSetS2() {
+		t.Errorf("Optional field S2 is set on initialization")
+	}
+	if ao.IsSetI2() {
+		t.Errorf("Optional field I2 is set on initialization")
+	}
+	if ao.IsSetB2() {
+		t.Errorf("Optional field B2 is set on initialization")
+	}
+	if ao.IsSetAa() {
+		t.Errorf("Optional field Aa is set on initialization")
+	}
+	if ao.IsSetL() {
+		t.Errorf("Optional field L is set on initialization")
+	}
+	if ao.IsSetL2() {
+		t.Errorf("Optional field L2 is set on initialization")
+	}
+	if ao.IsSetM() {
+		t.Errorf("Optional field M is set on initialization")
+	}
+	if ao.IsSetM2() {
+		t.Errorf("Optional field M2 is set on initialization")
+	}
+	if ao.IsSetBin() {
+		t.Errorf("Optional field Bin is set on initialization")
+	}
+	if ao.IsSetBin2() {
+		t.Errorf("Optional field Bin2 is set on initialization")
+	}
+}
+
+func TestDefaultValuesOnCreation(t *testing.T) {
+	ao := OptionalFieldsTest.NewAllOptional()
+	if ao.GetS() != "DEFAULT" {
+		t.Errorf("Unexpected default value %#v for field S", ao.GetS())
+	}
+	if ao.GetI() != 42 {
+		t.Errorf("Unexpected default value %#v for field I", ao.GetI())
+	}
+	if ao.GetB() != false {
+		t.Errorf("Unexpected default value %#v for field B", ao.GetB())
+	}
+	if ao.GetS2() != "" {
+		t.Errorf("Unexpected default value %#v for field S2", ao.GetS2())
+	}
+	if ao.GetI2() != 0 {
+		t.Errorf("Unexpected default value %#v for field I2", ao.GetI2())
+	}
+	if ao.GetB2() != false {
+		t.Errorf("Unexpected default value %#v for field B2", ao.GetB2())
+	}
+	if l := ao.GetL(); len(l) != 0 {
+		t.Errorf("Unexpected default value %#v for field L", l)
+	}
+	if l := ao.GetL2(); len(l) != 2 || l[0] != 1 || l[1] != 2 {
+		t.Errorf("Unexpected default value %#v for field L2", l)
+	}
+	//FIXME: should we return empty map here?
+	if m := ao.GetM(); m != nil {
+		t.Errorf("Unexpected default value %#v for field M", m)
+	}
+	if m := ao.GetM2(); len(m) != 2 || m[1] != 2 || m[3] != 4 {
+		t.Errorf("Unexpected default value %#v for field M2", m)
+	}
+	if bv := ao.GetBin(); bv != nil {
+		t.Errorf("Unexpected default value %#v for field Bin", bv)
+	}
+	if bv := ao.GetBin2(); !bytes.Equal(bv, []byte("asdf")) {
+		t.Errorf("Unexpected default value %#v for field Bin2", bv)
+	}
+}
+
+func TestInitialValuesOnCreation(t *testing.T) {
+	ao := OptionalFieldsTest.NewAllOptional()
+	if ao.S != "DEFAULT" {
+		t.Errorf("Unexpected initial value %#v for field S", ao.S)
+	}
+	if ao.I != 42 {
+		t.Errorf("Unexpected initial value %#v for field I", ao.I)
+	}
+	if ao.B != false {
+		t.Errorf("Unexpected initial value %#v for field B", ao.B)
+	}
+	if ao.S2 != nil {
+		t.Errorf("Unexpected initial value %#v for field S2", ao.S2)
+	}
+	if ao.I2 != nil {
+		t.Errorf("Unexpected initial value %#v for field I2", ao.I2)
+	}
+	if ao.B2 != nil {
+		t.Errorf("Unexpected initial value %#v for field B2", ao.B2)
+	}
+	if ao.L != nil || len(ao.L) != 0 {
+		t.Errorf("Unexpected initial value %#v for field L", ao.L)
+	}
+	if ao.L2 != nil {
+		t.Errorf("Unexpected initial value %#v for field L2", ao.L2)
+	}
+	if ao.M != nil {
+		t.Errorf("Unexpected initial value %#v for field M", ao.M)
+	}
+	if ao.M2 != nil {
+		t.Errorf("Unexpected initial value %#v for field M2", ao.M2)
+	}
+	if ao.Bin != nil || len(ao.Bin) != 0 {
+		t.Errorf("Unexpected initial value %#v for field Bin", ao.Bin)
+	}
+	if !bytes.Equal(ao.Bin2, []byte("asdf")) {
+		t.Errorf("Unexpected initial value %#v for field Bin2", ao.Bin2)
+	}
+}
+
+func TestIsSetReturnTrueAfterUpdate(t *testing.T) {
+	ao := OptionalFieldsTest.NewAllOptional()
+	ao.S = "somevalue"
+	ao.I = 123
+	ao.B = true
+	ao.Aa = OptionalFieldsTest.NewStructA()
+	if !ao.IsSetS() {
+		t.Errorf("Field S should be set")
+	}
+	if !ao.IsSetI() {
+		t.Errorf("Field I should be set")
+	}
+	if !ao.IsSetB() {
+		t.Errorf("Field B should be set")
+	}
+	if !ao.IsSetAa() {
+		t.Errorf("Field aa should be set")
+	}
+}
+
+func TestListNotEmpty(t *testing.T) {
+	ao := OptionalFieldsTest.NewAllOptional()
+	ao.L = []int64{1, 2, 3}
+	if !ao.IsSetL() {
+		t.Errorf("Field L should be set")
+	}
+}
+
+//Make sure that optional fields are not being serialized
+func TestNoOptionalUnsetFieldsOnWire(t *testing.T) {
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	proto := NewMockTProtocol(mockCtrl)
+	gomock.InOrder(
+		proto.EXPECT().WriteStructBegin("all_optional").Return(nil),
+		proto.EXPECT().WriteFieldStop().Return(nil),
+		proto.EXPECT().WriteStructEnd().Return(nil),
+	)
+	ao := OptionalFieldsTest.NewAllOptional()
+	ao.Write(proto)
+}
+
+func TestNoSetToDefaultFieldsOnWire(t *testing.T) {
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	proto := NewMockTProtocol(mockCtrl)
+	gomock.InOrder(
+		proto.EXPECT().WriteStructBegin("all_optional").Return(nil),
+		proto.EXPECT().WriteFieldStop().Return(nil),
+		proto.EXPECT().WriteStructEnd().Return(nil),
+	)
+	ao := OptionalFieldsTest.NewAllOptional()
+	ao.I = 42
+	ao.Write(proto)
+}
+
+//Make sure that only one field is being serialized when set to non-default
+func TestOneISetFieldOnWire(t *testing.T) {
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	proto := NewMockTProtocol(mockCtrl)
+	gomock.InOrder(
+		proto.EXPECT().WriteStructBegin("all_optional").Return(nil),
+		proto.EXPECT().WriteFieldBegin("i", thrift.TType(thrift.I64), int16(2)).Return(nil),
+		proto.EXPECT().WriteI64(int64(123)).Return(nil),
+		proto.EXPECT().WriteFieldEnd().Return(nil),
+		proto.EXPECT().WriteFieldStop().Return(nil),
+		proto.EXPECT().WriteStructEnd().Return(nil),
+	)
+	ao := OptionalFieldsTest.NewAllOptional()
+	ao.I = 123
+	ao.Write(proto)
+}
+
+func TestOneLSetFieldOnWire(t *testing.T) {
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	proto := NewMockTProtocol(mockCtrl)
+	gomock.InOrder(
+		proto.EXPECT().WriteStructBegin("all_optional").Return(nil),
+		proto.EXPECT().WriteFieldBegin("l", thrift.TType(thrift.LIST), int16(9)).Return(nil),
+		proto.EXPECT().WriteListBegin(thrift.TType(thrift.I64), 2).Return(nil),
+		proto.EXPECT().WriteI64(int64(1)).Return(nil),
+		proto.EXPECT().WriteI64(int64(2)).Return(nil),
+		proto.EXPECT().WriteListEnd().Return(nil),
+		proto.EXPECT().WriteFieldEnd().Return(nil),
+		proto.EXPECT().WriteFieldStop().Return(nil),
+		proto.EXPECT().WriteStructEnd().Return(nil),
+	)
+	ao := OptionalFieldsTest.NewAllOptional()
+	ao.L = []int64{1, 2}
+	ao.Write(proto)
+}
+
+func TestOneBinSetFieldOnWire(t *testing.T) {
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	proto := NewMockTProtocol(mockCtrl)
+	gomock.InOrder(
+		proto.EXPECT().WriteStructBegin("all_optional").Return(nil),
+		proto.EXPECT().WriteFieldBegin("bin", thrift.TType(thrift.STRING), int16(13)).Return(nil),
+		proto.EXPECT().WriteBinary([]byte("somebytestring")).Return(nil),
+		proto.EXPECT().WriteFieldEnd().Return(nil),
+		proto.EXPECT().WriteFieldStop().Return(nil),
+		proto.EXPECT().WriteStructEnd().Return(nil),
+	)
+	ao := OptionalFieldsTest.NewAllOptional()
+	ao.Bin = []byte("somebytestring")
+	ao.Write(proto)
+}
+
+func TestOneEmptyBinSetFieldOnWire(t *testing.T) {
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	proto := NewMockTProtocol(mockCtrl)
+	gomock.InOrder(
+		proto.EXPECT().WriteStructBegin("all_optional").Return(nil),
+		proto.EXPECT().WriteFieldBegin("bin", thrift.TType(thrift.STRING), int16(13)).Return(nil),
+		proto.EXPECT().WriteBinary([]byte{}).Return(nil),
+		proto.EXPECT().WriteFieldEnd().Return(nil),
+		proto.EXPECT().WriteFieldStop().Return(nil),
+		proto.EXPECT().WriteStructEnd().Return(nil),
+	)
+	ao := OptionalFieldsTest.NewAllOptional()
+	ao.Bin = []byte{}
+	ao.Write(proto)
+}
diff --git a/lib/go/test/tests/protocol_mock.go b/lib/go/test/tests/protocol_mock.go
new file mode 100644
index 0000000..d3f4078
--- /dev/null
+++ b/lib/go/test/tests/protocol_mock.go
@@ -0,0 +1,511 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+// Automatically generated by MockGen. DO NOT EDIT!
+// Source: thrift (interfaces: TProtocol)
+
+package tests
+
+import (
+	thrift "thrift"
+	gomock "code.google.com/p/gomock/gomock"
+)
+
+// Mock of TProtocol interface
+type MockTProtocol struct {
+	ctrl     *gomock.Controller
+	recorder *_MockTProtocolRecorder
+}
+
+// Recorder for MockTProtocol (not exported)
+type _MockTProtocolRecorder struct {
+	mock *MockTProtocol
+}
+
+func NewMockTProtocol(ctrl *gomock.Controller) *MockTProtocol {
+	mock := &MockTProtocol{ctrl: ctrl}
+	mock.recorder = &_MockTProtocolRecorder{mock}
+	return mock
+}
+
+func (_m *MockTProtocol) EXPECT() *_MockTProtocolRecorder {
+	return _m.recorder
+}
+
+func (_m *MockTProtocol) Flush() error {
+	ret := _m.ctrl.Call(_m, "Flush")
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockTProtocolRecorder) Flush() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Flush")
+}
+
+func (_m *MockTProtocol) ReadBinary() ([]byte, error) {
+	ret := _m.ctrl.Call(_m, "ReadBinary")
+	ret0, _ := ret[0].([]byte)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockTProtocolRecorder) ReadBinary() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadBinary")
+}
+
+func (_m *MockTProtocol) ReadBool() (bool, error) {
+	ret := _m.ctrl.Call(_m, "ReadBool")
+	ret0, _ := ret[0].(bool)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockTProtocolRecorder) ReadBool() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadBool")
+}
+
+func (_m *MockTProtocol) ReadByte() (byte, error) {
+	ret := _m.ctrl.Call(_m, "ReadByte")
+	ret0, _ := ret[0].(byte)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockTProtocolRecorder) ReadByte() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadByte")
+}
+
+func (_m *MockTProtocol) ReadDouble() (float64, error) {
+	ret := _m.ctrl.Call(_m, "ReadDouble")
+	ret0, _ := ret[0].(float64)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockTProtocolRecorder) ReadDouble() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadDouble")
+}
+
+func (_m *MockTProtocol) ReadFieldBegin() (string, thrift.TType, int16, error) {
+	ret := _m.ctrl.Call(_m, "ReadFieldBegin")
+	ret0, _ := ret[0].(string)
+	ret1, _ := ret[1].(thrift.TType)
+	ret2, _ := ret[2].(int16)
+	ret3, _ := ret[3].(error)
+	return ret0, ret1, ret2, ret3
+}
+
+func (_mr *_MockTProtocolRecorder) ReadFieldBegin() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadFieldBegin")
+}
+
+func (_m *MockTProtocol) ReadFieldEnd() error {
+	ret := _m.ctrl.Call(_m, "ReadFieldEnd")
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockTProtocolRecorder) ReadFieldEnd() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadFieldEnd")
+}
+
+func (_m *MockTProtocol) ReadI16() (int16, error) {
+	ret := _m.ctrl.Call(_m, "ReadI16")
+	ret0, _ := ret[0].(int16)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockTProtocolRecorder) ReadI16() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadI16")
+}
+
+func (_m *MockTProtocol) ReadI32() (int32, error) {
+	ret := _m.ctrl.Call(_m, "ReadI32")
+	ret0, _ := ret[0].(int32)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockTProtocolRecorder) ReadI32() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadI32")
+}
+
+func (_m *MockTProtocol) ReadI64() (int64, error) {
+	ret := _m.ctrl.Call(_m, "ReadI64")
+	ret0, _ := ret[0].(int64)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockTProtocolRecorder) ReadI64() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadI64")
+}
+
+func (_m *MockTProtocol) ReadListBegin() (thrift.TType, int, error) {
+	ret := _m.ctrl.Call(_m, "ReadListBegin")
+	ret0, _ := ret[0].(thrift.TType)
+	ret1, _ := ret[1].(int)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+func (_mr *_MockTProtocolRecorder) ReadListBegin() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadListBegin")
+}
+
+func (_m *MockTProtocol) ReadListEnd() error {
+	ret := _m.ctrl.Call(_m, "ReadListEnd")
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockTProtocolRecorder) ReadListEnd() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadListEnd")
+}
+
+func (_m *MockTProtocol) ReadMapBegin() (thrift.TType, thrift.TType, int, error) {
+	ret := _m.ctrl.Call(_m, "ReadMapBegin")
+	ret0, _ := ret[0].(thrift.TType)
+	ret1, _ := ret[1].(thrift.TType)
+	ret2, _ := ret[2].(int)
+	ret3, _ := ret[3].(error)
+	return ret0, ret1, ret2, ret3
+}
+
+func (_mr *_MockTProtocolRecorder) ReadMapBegin() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadMapBegin")
+}
+
+func (_m *MockTProtocol) ReadMapEnd() error {
+	ret := _m.ctrl.Call(_m, "ReadMapEnd")
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockTProtocolRecorder) ReadMapEnd() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadMapEnd")
+}
+
+func (_m *MockTProtocol) ReadMessageBegin() (string, thrift.TMessageType, int32, error) {
+	ret := _m.ctrl.Call(_m, "ReadMessageBegin")
+	ret0, _ := ret[0].(string)
+	ret1, _ := ret[1].(thrift.TMessageType)
+	ret2, _ := ret[2].(int32)
+	ret3, _ := ret[3].(error)
+	return ret0, ret1, ret2, ret3
+}
+
+func (_mr *_MockTProtocolRecorder) ReadMessageBegin() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadMessageBegin")
+}
+
+func (_m *MockTProtocol) ReadMessageEnd() error {
+	ret := _m.ctrl.Call(_m, "ReadMessageEnd")
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockTProtocolRecorder) ReadMessageEnd() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadMessageEnd")
+}
+
+func (_m *MockTProtocol) ReadSetBegin() (thrift.TType, int, error) {
+	ret := _m.ctrl.Call(_m, "ReadSetBegin")
+	ret0, _ := ret[0].(thrift.TType)
+	ret1, _ := ret[1].(int)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+func (_mr *_MockTProtocolRecorder) ReadSetBegin() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadSetBegin")
+}
+
+func (_m *MockTProtocol) ReadSetEnd() error {
+	ret := _m.ctrl.Call(_m, "ReadSetEnd")
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockTProtocolRecorder) ReadSetEnd() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadSetEnd")
+}
+
+func (_m *MockTProtocol) ReadString() (string, error) {
+	ret := _m.ctrl.Call(_m, "ReadString")
+	ret0, _ := ret[0].(string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockTProtocolRecorder) ReadString() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadString")
+}
+
+func (_m *MockTProtocol) ReadStructBegin() (string, error) {
+	ret := _m.ctrl.Call(_m, "ReadStructBegin")
+	ret0, _ := ret[0].(string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockTProtocolRecorder) ReadStructBegin() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadStructBegin")
+}
+
+func (_m *MockTProtocol) ReadStructEnd() error {
+	ret := _m.ctrl.Call(_m, "ReadStructEnd")
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockTProtocolRecorder) ReadStructEnd() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReadStructEnd")
+}
+
+func (_m *MockTProtocol) Skip(_param0 thrift.TType) error {
+	ret := _m.ctrl.Call(_m, "Skip", _param0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockTProtocolRecorder) Skip(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Skip", arg0)
+}
+
+func (_m *MockTProtocol) Transport() thrift.TTransport {
+	ret := _m.ctrl.Call(_m, "Transport")
+	ret0, _ := ret[0].(thrift.TTransport)
+	return ret0
+}
+
+func (_mr *_MockTProtocolRecorder) Transport() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Transport")
+}
+
+func (_m *MockTProtocol) WriteBinary(_param0 []byte) error {
+	ret := _m.ctrl.Call(_m, "WriteBinary", _param0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockTProtocolRecorder) WriteBinary(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteBinary", arg0)
+}
+
+func (_m *MockTProtocol) WriteBool(_param0 bool) error {
+	ret := _m.ctrl.Call(_m, "WriteBool", _param0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockTProtocolRecorder) WriteBool(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteBool", arg0)
+}
+
+func (_m *MockTProtocol) WriteByte(_param0 byte) error {
+	ret := _m.ctrl.Call(_m, "WriteByte", _param0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockTProtocolRecorder) WriteByte(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteByte", arg0)
+}
+
+func (_m *MockTProtocol) WriteDouble(_param0 float64) error {
+	ret := _m.ctrl.Call(_m, "WriteDouble", _param0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockTProtocolRecorder) WriteDouble(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteDouble", arg0)
+}
+
+func (_m *MockTProtocol) WriteFieldBegin(_param0 string, _param1 thrift.TType, _param2 int16) error {
+	ret := _m.ctrl.Call(_m, "WriteFieldBegin", _param0, _param1, _param2)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockTProtocolRecorder) WriteFieldBegin(arg0, arg1, arg2 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteFieldBegin", arg0, arg1, arg2)
+}
+
+func (_m *MockTProtocol) WriteFieldEnd() error {
+	ret := _m.ctrl.Call(_m, "WriteFieldEnd")
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockTProtocolRecorder) WriteFieldEnd() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteFieldEnd")
+}
+
+func (_m *MockTProtocol) WriteFieldStop() error {
+	ret := _m.ctrl.Call(_m, "WriteFieldStop")
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockTProtocolRecorder) WriteFieldStop() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteFieldStop")
+}
+
+func (_m *MockTProtocol) WriteI16(_param0 int16) error {
+	ret := _m.ctrl.Call(_m, "WriteI16", _param0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockTProtocolRecorder) WriteI16(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteI16", arg0)
+}
+
+func (_m *MockTProtocol) WriteI32(_param0 int32) error {
+	ret := _m.ctrl.Call(_m, "WriteI32", _param0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockTProtocolRecorder) WriteI32(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteI32", arg0)
+}
+
+func (_m *MockTProtocol) WriteI64(_param0 int64) error {
+	ret := _m.ctrl.Call(_m, "WriteI64", _param0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockTProtocolRecorder) WriteI64(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteI64", arg0)
+}
+
+func (_m *MockTProtocol) WriteListBegin(_param0 thrift.TType, _param1 int) error {
+	ret := _m.ctrl.Call(_m, "WriteListBegin", _param0, _param1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockTProtocolRecorder) WriteListBegin(arg0, arg1 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteListBegin", arg0, arg1)
+}
+
+func (_m *MockTProtocol) WriteListEnd() error {
+	ret := _m.ctrl.Call(_m, "WriteListEnd")
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockTProtocolRecorder) WriteListEnd() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteListEnd")
+}
+
+func (_m *MockTProtocol) WriteMapBegin(_param0 thrift.TType, _param1 thrift.TType, _param2 int) error {
+	ret := _m.ctrl.Call(_m, "WriteMapBegin", _param0, _param1, _param2)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockTProtocolRecorder) WriteMapBegin(arg0, arg1, arg2 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteMapBegin", arg0, arg1, arg2)
+}
+
+func (_m *MockTProtocol) WriteMapEnd() error {
+	ret := _m.ctrl.Call(_m, "WriteMapEnd")
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockTProtocolRecorder) WriteMapEnd() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteMapEnd")
+}
+
+func (_m *MockTProtocol) WriteMessageBegin(_param0 string, _param1 thrift.TMessageType, _param2 int32) error {
+	ret := _m.ctrl.Call(_m, "WriteMessageBegin", _param0, _param1, _param2)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockTProtocolRecorder) WriteMessageBegin(arg0, arg1, arg2 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteMessageBegin", arg0, arg1, arg2)
+}
+
+func (_m *MockTProtocol) WriteMessageEnd() error {
+	ret := _m.ctrl.Call(_m, "WriteMessageEnd")
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockTProtocolRecorder) WriteMessageEnd() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteMessageEnd")
+}
+
+func (_m *MockTProtocol) WriteSetBegin(_param0 thrift.TType, _param1 int) error {
+	ret := _m.ctrl.Call(_m, "WriteSetBegin", _param0, _param1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockTProtocolRecorder) WriteSetBegin(arg0, arg1 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteSetBegin", arg0, arg1)
+}
+
+func (_m *MockTProtocol) WriteSetEnd() error {
+	ret := _m.ctrl.Call(_m, "WriteSetEnd")
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockTProtocolRecorder) WriteSetEnd() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteSetEnd")
+}
+
+func (_m *MockTProtocol) WriteString(_param0 string) error {
+	ret := _m.ctrl.Call(_m, "WriteString", _param0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockTProtocolRecorder) WriteString(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteString", arg0)
+}
+
+func (_m *MockTProtocol) WriteStructBegin(_param0 string) error {
+	ret := _m.ctrl.Call(_m, "WriteStructBegin", _param0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockTProtocolRecorder) WriteStructBegin(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteStructBegin", arg0)
+}
+
+func (_m *MockTProtocol) WriteStructEnd() error {
+	ret := _m.ctrl.Call(_m, "WriteStructEnd")
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockTProtocolRecorder) WriteStructEnd() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "WriteStructEnd")
+}