diff --git a/settable_test.go b/settable_test.go
new file mode 100644
index 0000000..c65eb7e
--- /dev/null
+++ b/settable_test.go
@@ -0,0 +1,770 @@
+/*
+ * Copyright (c) 2018 - present.  Boling Consulting Solutions (bcsw.net)
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed 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 omci_test
+
+import (
+	"github.com/google/gopacket"
+	. "github.com/opencord/omci-lib-go"
+	me "github.com/opencord/omci-lib-go/generated"
+	"github.com/stretchr/testify/assert"
+	"strings"
+	"testing"
+)
+
+func TestSetTableRequestDecode(t *testing.T) {
+	// Single row
+	row := "F0000000" + "F0000000" + "00000000" + "00000000"
+	goodMessage := "01075d0b00AB123400120400"
+	data, err := stringToPacket(goodMessage + row)
+	assert.NoError(t, err)
+
+	packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.NoCopy)
+	assert.NotNil(t, packet)
+
+	omciLayer := packet.Layer(LayerTypeOMCI)
+	assert.NotNil(t, omciLayer)
+
+	omciMsg, ok := omciLayer.(*OMCI)
+	assert.True(t, ok)
+	assert.NotNil(t, omciMsg)
+	assert.Equal(t, LayerTypeOMCI, omciMsg.LayerType())
+	assert.Equal(t, LayerTypeOMCI, omciMsg.CanDecode())
+	assert.Equal(t, LayerTypeSetTableRequest, omciMsg.NextLayerType())
+	assert.Equal(t, uint16(0x0107), omciMsg.TransactionID)
+	assert.Equal(t, SetTableRequestType, omciMsg.MessageType)
+	assert.Equal(t, ExtendedIdent, omciMsg.DeviceIdentifier)
+	assert.Equal(t, uint16(2+16), omciMsg.Length)
+
+	msgLayer := packet.Layer(LayerTypeSetTableRequest)
+	assert.NotNil(t, msgLayer)
+
+	request, ok2 := msgLayer.(*SetTableRequest)
+	assert.True(t, ok2)
+	assert.NotNil(t, request)
+	assert.Equal(t, LayerTypeSetTableRequest, request.LayerType())
+	assert.Equal(t, LayerTypeSetTableRequest, request.CanDecode())
+	assert.Equal(t, gopacket.LayerTypePayload, request.NextLayerType())
+
+	assert.Equal(t, me.ExtendedVlanTaggingOperationConfigurationDataClassID, request.EntityClass)
+	assert.Equal(t, uint16(0x1234), request.EntityInstance)
+	assert.Equal(t, uint16(0x0400), request.AttributeMask)
+
+	vlanTable, tblOk := request.Attributes["ReceivedFrameVlanTaggingOperationTable"]
+	assert.True(t, tblOk)
+	assert.NotNil(t, vlanTable)
+
+	rows, rowOk := vlanTable.(me.TableRows)
+	assert.True(t, rowOk)
+	assert.NotNil(t, rows)
+	assert.Equal(t, 1, rows.NumRows)
+	assert.Equal(t, 16*rows.NumRows, len(rows.Rows))
+
+	// Verify string output for message
+	packetString := packet.String()
+	assert.NotZero(t, len(packetString))
+}
+
+func TestSetTableRequestDecodeZeroRows(t *testing.T) {
+	// No rows are okay
+	row := ""
+	goodMessage := "01075d0b00AB123400020400"
+	data, err := stringToPacket(goodMessage + row)
+	assert.NoError(t, err)
+
+	packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.NoCopy)
+	assert.NotNil(t, packet)
+
+	omciLayer := packet.Layer(LayerTypeOMCI)
+	assert.NotNil(t, omciLayer)
+
+	omciMsg, ok := omciLayer.(*OMCI)
+	assert.True(t, ok)
+	assert.NotNil(t, omciMsg)
+	assert.Equal(t, uint16(2), omciMsg.Length)
+
+	msgLayer := packet.Layer(LayerTypeSetTableRequest)
+	assert.NotNil(t, msgLayer)
+
+	request, ok2 := msgLayer.(*SetTableRequest)
+	assert.True(t, ok2)
+	assert.NotNil(t, request)
+	assert.Equal(t, me.ExtendedVlanTaggingOperationConfigurationDataClassID, request.EntityClass)
+	assert.Equal(t, uint16(0x1234), request.EntityInstance)
+	assert.Equal(t, uint16(0x0400), request.AttributeMask)
+
+	vlanTable, tblOk := request.Attributes["ReceivedFrameVlanTaggingOperationTable"]
+	assert.True(t, tblOk)
+	assert.NotNil(t, vlanTable)
+
+	rows, rowOk := vlanTable.(me.TableRows)
+	assert.True(t, rowOk)
+	assert.NotNil(t, rows)
+	assert.Equal(t, 0, rows.NumRows)
+	assert.Nil(t, rows.Rows)
+
+	// Verify string output for message
+	packetString := packet.String()
+	assert.NotZero(t, len(packetString))
+}
+
+func TestSetTableRequestDecodeMultipleRows(t *testing.T) {
+	// More than one row
+	row1 := "F0000000" + "F0000000" + "00000000" + "00000000"
+	row2 := "70000000" + "F0000000" + "00000000" + "00000000"
+	row3 := "70000000" + "70000000" + "00000000" + "00000000"
+	goodMessage := "01075d0b00AB123400320400"
+	data, err := stringToPacket(goodMessage + row1 + row2 + row3)
+	assert.NoError(t, err)
+
+	packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.NoCopy)
+	assert.NotNil(t, packet)
+
+	omciLayer := packet.Layer(LayerTypeOMCI)
+	assert.NotNil(t, omciLayer)
+
+	omciMsg, ok := omciLayer.(*OMCI)
+	assert.True(t, ok)
+	assert.NotNil(t, omciMsg)
+	assert.Equal(t, uint16(2+(3*16)), omciMsg.Length)
+
+	msgLayer := packet.Layer(LayerTypeSetTableRequest)
+	assert.NotNil(t, msgLayer)
+
+	request, ok2 := msgLayer.(*SetTableRequest)
+	assert.True(t, ok2)
+	assert.NotNil(t, request)
+	vlanTable, tblOk := request.Attributes["ReceivedFrameVlanTaggingOperationTable"]
+	assert.True(t, tblOk)
+	assert.NotNil(t, vlanTable)
+
+	rows, rowOk := vlanTable.(me.TableRows)
+	assert.True(t, rowOk)
+	assert.NotNil(t, rows)
+	assert.Equal(t, 3, rows.NumRows)
+	assert.Equal(t, 16*rows.NumRows, len(rows.Rows))
+
+	// Verify string output for message
+	packetString := packet.String()
+	assert.NotZero(t, len(packetString))
+}
+
+func TestSetTableRequestDecodeTruncatedRow(t *testing.T) {
+	// More than one row, but one is short
+	row1 := "F0000000" + "F0000000" + "00000000" + "00000000"
+	row2 := "70000000" + "F0000000" + "00000000" + "00000000"
+	row3 := "70000000" + "70000000" + "00000000" + "0000"
+	goodMessage := "01075d0b00ab123400300400"
+	data, err := stringToPacket(goodMessage + row1 + row2 + row3)
+	assert.NoError(t, err)
+
+	packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.NoCopy)
+	assert.NotNil(t, packet)
+
+	omciLayer := packet.Layer(LayerTypeOMCI)
+	assert.NotNil(t, omciLayer)
+
+	omciMsg, ok := omciLayer.(*OMCI)
+	assert.True(t, ok)
+	assert.NotNil(t, omciMsg)
+	assert.Equal(t, uint16(48), omciMsg.Length)
+
+	msgLayer := packet.Layer(LayerTypeSetTableRequest)
+	assert.Nil(t, msgLayer)
+
+	shortLayer := packet.Layer(gopacket.LayerTypeDecodeFailure)
+	assert.NotNil(t, shortLayer)
+	assert.True(t, packet.Metadata().Truncated)
+}
+
+func TestSetTableRequestDecodeOneAttributeOnly(t *testing.T) {
+	// Single row but also extra non-table row
+	row := "F0000000" + "F0000000" + "00000000" + "00000000"
+	goodMessage := "01075d0b00ab123400138400" + "00"
+	data, err := stringToPacket(goodMessage + row)
+	assert.NoError(t, err)
+
+	packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.NoCopy)
+	assert.NotNil(t, packet)
+
+	omciLayer := packet.Layer(LayerTypeOMCI)
+	assert.NotNil(t, omciLayer)
+
+	omciMsg, ok := omciLayer.(*OMCI)
+	assert.True(t, ok)
+	assert.NotNil(t, omciMsg)
+	assert.Equal(t, LayerTypeOMCI, omciMsg.LayerType())
+	assert.Equal(t, LayerTypeOMCI, omciMsg.CanDecode())
+	assert.Equal(t, LayerTypeSetTableRequest, omciMsg.NextLayerType())
+	assert.Equal(t, uint16(0x0107), omciMsg.TransactionID)
+	assert.Equal(t, SetTableRequestType, omciMsg.MessageType)
+	assert.Equal(t, ExtendedIdent, omciMsg.DeviceIdentifier)
+	assert.Equal(t, uint16(3+16), omciMsg.Length)
+
+	msgLayer := packet.Layer(LayerTypeSetTableRequest)
+	assert.Nil(t, msgLayer)
+
+	badLayer := packet.Layer(gopacket.LayerTypeDecodeFailure)
+	assert.NotNil(t, badLayer)
+	assert.False(t, packet.Metadata().Truncated) // It was correct length, but not right
+
+	failure, ok3 := badLayer.(*gopacket.DecodeFailure)
+	assert.True(t, ok3)
+	assert.NotNil(t, failure)
+}
+
+func TestSetTableRequestDecodeTableAttributesOnly(t *testing.T) {
+
+	// Single row but also extra non-table row
+	goodMessage := "01075d0b00ab123400038000" + "00"
+	data, err := stringToPacket(goodMessage)
+	assert.NoError(t, err)
+
+	packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.NoCopy)
+	assert.NotNil(t, packet)
+
+	omciLayer := packet.Layer(LayerTypeOMCI)
+	assert.NotNil(t, omciLayer)
+
+	omciMsg, ok := omciLayer.(*OMCI)
+	assert.True(t, ok)
+	assert.NotNil(t, omciMsg)
+	assert.Equal(t, LayerTypeOMCI, omciMsg.LayerType())
+	assert.Equal(t, LayerTypeOMCI, omciMsg.CanDecode())
+	assert.Equal(t, LayerTypeSetTableRequest, omciMsg.NextLayerType())
+	assert.Equal(t, uint16(0x0107), omciMsg.TransactionID)
+	assert.Equal(t, SetTableRequestType, omciMsg.MessageType)
+	assert.Equal(t, ExtendedIdent, omciMsg.DeviceIdentifier)
+	assert.Equal(t, uint16(3), omciMsg.Length)
+
+	msgLayer := packet.Layer(LayerTypeSetTableRequest)
+	assert.Nil(t, msgLayer)
+
+	badLayer := packet.Layer(gopacket.LayerTypeDecodeFailure)
+	assert.NotNil(t, badLayer)
+	assert.False(t, packet.Metadata().Truncated) // It was correct length, but not right
+
+	failure, ok3 := badLayer.(*gopacket.DecodeFailure)
+	assert.True(t, ok3)
+	assert.NotNil(t, failure)
+}
+
+func TestSetTableRequestDecodeMeNotSupported(t *testing.T) {
+
+	// Single row but also extra non-table row
+	goodMessage := "01075d0b0100000000031000" + "01"
+	data, err := stringToPacket(goodMessage)
+	assert.NoError(t, err)
+
+	packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.NoCopy)
+	assert.NotNil(t, packet)
+
+	omciLayer := packet.Layer(LayerTypeOMCI)
+	assert.NotNil(t, omciLayer)
+
+	omciMsg, ok := omciLayer.(*OMCI)
+	assert.True(t, ok)
+	assert.NotNil(t, omciMsg)
+	assert.Equal(t, LayerTypeOMCI, omciMsg.LayerType())
+	assert.Equal(t, LayerTypeOMCI, omciMsg.CanDecode())
+	assert.Equal(t, LayerTypeSetTableRequest, omciMsg.NextLayerType())
+	assert.Equal(t, uint16(0x0107), omciMsg.TransactionID)
+	assert.Equal(t, SetTableRequestType, omciMsg.MessageType)
+	assert.Equal(t, ExtendedIdent, omciMsg.DeviceIdentifier)
+	assert.Equal(t, uint16(3), omciMsg.Length)
+
+	msgLayer := packet.Layer(LayerTypeSetTableRequest)
+	assert.Nil(t, msgLayer)
+
+	badLayer := packet.Layer(gopacket.LayerTypeDecodeFailure)
+	assert.NotNil(t, badLayer)
+	assert.False(t, packet.Metadata().Truncated) // It was correct length, but not right
+
+	failure, ok3 := badLayer.(*gopacket.DecodeFailure)
+	assert.True(t, ok3)
+	assert.NotNil(t, failure)
+}
+
+func TestSetTableRequestDecodeTableWritableOnly(t *testing.T) {
+
+	// Single row but also extra non-table row
+	goodMessage := "01075d0b00ab123400044000" + "0000"
+	data, err := stringToPacket(goodMessage)
+	assert.NoError(t, err)
+
+	packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.NoCopy)
+	assert.NotNil(t, packet)
+
+	omciLayer := packet.Layer(LayerTypeOMCI)
+	assert.NotNil(t, omciLayer)
+
+	omciMsg, ok := omciLayer.(*OMCI)
+	assert.True(t, ok)
+	assert.NotNil(t, omciMsg)
+	assert.Equal(t, LayerTypeOMCI, omciMsg.LayerType())
+	assert.Equal(t, LayerTypeOMCI, omciMsg.CanDecode())
+	assert.Equal(t, LayerTypeSetTableRequest, omciMsg.NextLayerType())
+	assert.Equal(t, uint16(0x0107), omciMsg.TransactionID)
+	assert.Equal(t, SetTableRequestType, omciMsg.MessageType)
+	assert.Equal(t, ExtendedIdent, omciMsg.DeviceIdentifier)
+	assert.Equal(t, uint16(4), omciMsg.Length)
+
+	msgLayer := packet.Layer(LayerTypeSetTableRequest)
+	assert.Nil(t, msgLayer)
+
+	badLayer := packet.Layer(gopacket.LayerTypeDecodeFailure)
+	assert.NotNil(t, badLayer)
+	assert.False(t, packet.Metadata().Truncated) // It was correct length, but not right
+
+	failure, ok3 := badLayer.(*gopacket.DecodeFailure)
+	assert.True(t, ok3)
+	assert.NotNil(t, failure)
+}
+
+func TestSetTableRequestDecodeBaselineNotSupported(t *testing.T) {
+	// Single row
+	message := "01075d0a00AB1234001204000000000000000000000000000000000000000000000000000000000000000028"
+	data, err := stringToPacket(message)
+	assert.NoError(t, err)
+
+	packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.NoCopy)
+	assert.NotNil(t, packet)
+
+	omciLayer := packet.Layer(LayerTypeOMCI)
+	assert.NotNil(t, omciLayer)
+
+	omciMsg, ok := omciLayer.(*OMCI)
+	assert.True(t, ok)
+	assert.NotNil(t, omciMsg)
+	assert.Equal(t, uint16(0x0107), omciMsg.TransactionID)
+	assert.Equal(t, SetTableRequestType, omciMsg.MessageType)
+
+	msgLayer := packet.Layer(LayerTypeSetTableRequest)
+	assert.Nil(t, msgLayer)
+
+	badLayer := packet.Layer(gopacket.LayerTypeDecodeFailure)
+	assert.NotNil(t, badLayer)
+	assert.False(t, packet.Metadata().Truncated)
+}
+
+func TestSetTableRequestSerialize(t *testing.T) {
+	// Single row
+	row := "F0000001" + "F0000002" + "00000003" + "00000004"
+	goodMessage := "01075d0b00AB123400120400" + row
+
+	rowData, rErr := stringToPacket(row)
+	assert.NoError(t, rErr)
+
+	omciLayer := &OMCI{
+		TransactionID:    0x0107,
+		MessageType:      SetTableRequestType,
+		DeviceIdentifier: ExtendedIdent,
+	}
+	tableRow := me.TableRows{
+		NumRows: 1,
+		Rows:    rowData,
+	}
+	request := &SetTableRequest{
+		MeBasePacket: MeBasePacket{
+			EntityClass:    me.ExtendedVlanTaggingOperationConfigurationDataClassID,
+			EntityInstance: uint16(0x1234),
+			Extended:       true,
+		},
+		AttributeMask: uint16(0x0400),
+		Attributes:    me.AttributeValueMap{"ReceivedFrameVlanTaggingOperationTable": tableRow},
+	}
+	// Test serialization back to former string
+	var options gopacket.SerializeOptions
+	options.FixLengths = true
+
+	buffer := gopacket.NewSerializeBuffer()
+	err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
+	assert.NoError(t, err)
+
+	outgoingPacket := buffer.Bytes()
+	reconstituted := packetToString(outgoingPacket)
+	assert.Equal(t, strings.ToLower(goodMessage), reconstituted)
+}
+
+func TestSetTableRequestZeroTICSerialize(t *testing.T) {
+	// Single row
+	row := "F0000001" + "F0000002" + "00000003" + "00000004"
+	rowData, rErr := stringToPacket(row)
+	assert.NoError(t, rErr)
+
+	omciLayer := &OMCI{
+		TransactionID:    0x0,
+		MessageType:      SetTableRequestType,
+		DeviceIdentifier: ExtendedIdent,
+	}
+	tableRow := me.TableRows{
+		NumRows: 1,
+		Rows:    rowData,
+	}
+	request := &SetTableRequest{
+		MeBasePacket: MeBasePacket{
+			EntityClass:    me.ExtendedVlanTaggingOperationConfigurationDataClassID,
+			EntityInstance: uint16(0x1234),
+			Extended:       true,
+		},
+		AttributeMask: uint16(0x0400),
+		Attributes:    me.AttributeValueMap{"ReceivedFrameVlanTaggingOperationTable": tableRow},
+	}
+	// Test serialization back to former string
+	var options gopacket.SerializeOptions
+	options.FixLengths = true
+
+	buffer := gopacket.NewSerializeBuffer()
+	err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
+	assert.Error(t, err)
+}
+
+func TestSetTableRequestSerializeZeroRows(t *testing.T) {
+	// No rows is sort of dumb on a set but technically it is allowed
+	goodMessage := "01075d0b00AB123400020400"
+
+	omciLayer := &OMCI{
+		TransactionID:    0x0107,
+		MessageType:      SetTableRequestType,
+		DeviceIdentifier: ExtendedIdent,
+	}
+	tableRow := me.TableRows{}
+	request := &SetTableRequest{
+		MeBasePacket: MeBasePacket{
+			EntityClass:    me.ExtendedVlanTaggingOperationConfigurationDataClassID,
+			EntityInstance: uint16(0x1234),
+			Extended:       true,
+		},
+		AttributeMask: uint16(0x0400),
+		Attributes:    me.AttributeValueMap{"ReceivedFrameVlanTaggingOperationTable": tableRow},
+	}
+	// Test serialization back to former string
+	var options gopacket.SerializeOptions
+	options.FixLengths = true
+
+	buffer := gopacket.NewSerializeBuffer()
+	err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
+	assert.NoError(t, err)
+
+	outgoingPacket := buffer.Bytes()
+	reconstituted := packetToString(outgoingPacket)
+	assert.Equal(t, strings.ToLower(goodMessage), reconstituted)
+}
+
+func TestSetTableRequestSerializeMultipleRows(t *testing.T) {
+	// More than one row
+	row1 := "F0000000" + "F0000000" + "00004000" + "0000000c"
+	row2 := "70000000" + "F0000000" + "00300000" + "0000000a"
+	row3 := "70000000" + "70000000" + "0005000b" + "0000000b"
+	goodMessage := "01075d0b00AB123400320400" + row1 + row2 + row3
+
+	rowData, rErr := stringToPacket(row1 + row2 + row3)
+	assert.NoError(t, rErr)
+
+	omciLayer := &OMCI{
+		TransactionID:    0x0107,
+		MessageType:      SetTableRequestType,
+		DeviceIdentifier: ExtendedIdent,
+	}
+	tableRow := me.TableRows{
+		NumRows: 3,
+		Rows:    rowData,
+	}
+	request := &SetTableRequest{
+		MeBasePacket: MeBasePacket{
+			EntityClass:    me.ExtendedVlanTaggingOperationConfigurationDataClassID,
+			EntityInstance: uint16(0x1234),
+			Extended:       true,
+		},
+		AttributeMask: uint16(0x0400),
+		Attributes:    me.AttributeValueMap{"ReceivedFrameVlanTaggingOperationTable": tableRow},
+	}
+	// Test serialization back to former string
+	var options gopacket.SerializeOptions
+	options.FixLengths = true
+
+	buffer := gopacket.NewSerializeBuffer()
+	err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
+	assert.NoError(t, err)
+
+	outgoingPacket := buffer.Bytes()
+	reconstituted := packetToString(outgoingPacket)
+	assert.Equal(t, strings.ToLower(goodMessage), reconstituted)
+}
+
+func TestSetTableRequestSerializeTruncatedRow(t *testing.T) {
+	// More than one row, but one is short
+	row1 := "F0000000" + "F0000000" + "00000000" + "00000000"
+	row2 := "70000000" + "F0000000" + "00000000" + "00000000"
+	row3 := "70000000" + "70000000" + "00000000" + "0000"
+
+	rowData, rErr := stringToPacket(row1 + row2 + row3)
+	assert.NoError(t, rErr)
+
+	omciLayer := &OMCI{
+		TransactionID:    0x0107,
+		MessageType:      SetTableRequestType,
+		DeviceIdentifier: ExtendedIdent,
+	}
+	tableRow := me.TableRows{
+		NumRows: 3,
+		Rows:    rowData,
+	}
+	request := &SetTableRequest{
+		MeBasePacket: MeBasePacket{
+			EntityClass:    me.ExtendedVlanTaggingOperationConfigurationDataClassID,
+			EntityInstance: uint16(0x1234),
+			Extended:       true,
+		},
+		AttributeMask: uint16(0x0400),
+		Attributes:    me.AttributeValueMap{"ReceivedFrameVlanTaggingOperationTable": tableRow},
+	}
+	// Test serialization back to former string
+	var options gopacket.SerializeOptions
+	options.FixLengths = true
+
+	buffer := gopacket.NewSerializeBuffer()
+	err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
+	assert.Error(t, err)
+}
+
+func TestSetTableRequestSerializeOneAttributeOnly(t *testing.T) {
+	rowData, rErr := stringToPacket("F0000000" + "F0000000" + "00000000" + "00000000")
+	assert.NoError(t, rErr)
+
+	omciLayer := &OMCI{
+		TransactionID:    0x0107,
+		MessageType:      SetTableRequestType,
+		DeviceIdentifier: ExtendedIdent,
+	}
+	tableRow := me.TableRows{
+		NumRows: 1,
+		Rows:    rowData,
+	}
+	request := &SetTableRequest{
+		MeBasePacket: MeBasePacket{
+			EntityClass:    me.ExtendedVlanTaggingOperationConfigurationDataClassID,
+			EntityInstance: uint16(0x1234),
+			Extended:       true,
+		},
+		AttributeMask: uint16(0x8400),
+		Attributes: me.AttributeValueMap{
+			"ReceivedFrameVlanTaggingOperationTable": tableRow,
+			"AssociationType":                        byte(1),
+		},
+	}
+	// Test serialization back to former string
+	var options gopacket.SerializeOptions
+	options.FixLengths = true
+
+	buffer := gopacket.NewSerializeBuffer()
+	err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
+	assert.Error(t, err)
+}
+
+func TestSetTableRequestSerializeTableAttributesOnly(t *testing.T) {
+	omciLayer := &OMCI{
+		TransactionID:    0x0107,
+		MessageType:      SetTableRequestType,
+		DeviceIdentifier: ExtendedIdent,
+	}
+	request := &SetTableRequest{
+		MeBasePacket: MeBasePacket{
+			EntityClass:    me.ExtendedVlanTaggingOperationConfigurationDataClassID,
+			EntityInstance: uint16(0x1234),
+			Extended:       true,
+		},
+		AttributeMask: uint16(0x8000),
+		Attributes: me.AttributeValueMap{
+			"AssociationType": byte(1),
+		},
+	}
+	// Test serialization back to former string
+	var options gopacket.SerializeOptions
+	options.FixLengths = true
+
+	buffer := gopacket.NewSerializeBuffer()
+	err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
+	assert.Error(t, err)
+}
+
+func TestSetTableRequestSerializeTableWritableOnly(t *testing.T) {
+	omciLayer := &OMCI{
+		TransactionID:    0x0107,
+		MessageType:      SetTableRequestType,
+		DeviceIdentifier: ExtendedIdent,
+	}
+	request := &SetTableRequest{
+		MeBasePacket: MeBasePacket{
+			EntityClass:    me.ExtendedVlanTaggingOperationConfigurationDataClassID,
+			EntityInstance: uint16(0x1234),
+			Extended:       true,
+		},
+		AttributeMask: uint16(0x4000),
+		Attributes: me.AttributeValueMap{
+			"ReceivedFrameVlanTaggingOperationTableMaxSize": byte(1),
+		},
+	}
+	// Test serialization back to former string
+	var options gopacket.SerializeOptions
+	options.FixLengths = true
+
+	buffer := gopacket.NewSerializeBuffer()
+	err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
+	assert.Error(t, err)
+}
+
+func TestSetTableRequestSerializeBaselineNotSupported(t *testing.T) {
+	omciLayer := &OMCI{
+		TransactionID:    0x0107,
+		MessageType:      SetTableRequestType,
+		DeviceIdentifier: BaselineIdent,
+	}
+	tableRow := me.TableRows{}
+	request := &SetTableRequest{
+		MeBasePacket: MeBasePacket{
+			EntityClass:    me.ExtendedVlanTaggingOperationConfigurationDataClassID,
+			EntityInstance: uint16(0x1234),
+			Extended:       false,
+		},
+		AttributeMask: uint16(0x0400),
+		Attributes:    me.AttributeValueMap{"ReceivedFrameVlanTaggingOperationTable": tableRow},
+	}
+	// Test serialization back to former string
+	var options gopacket.SerializeOptions
+	options.FixLengths = true
+
+	buffer := gopacket.NewSerializeBuffer()
+	err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
+	assert.Error(t, err)
+}
+
+func TestSetTableRequestSerializeBaselineManageEntityNotSupported(t *testing.T) {
+	omciLayer := &OMCI{
+		TransactionID:    0x0107,
+		MessageType:      SetTableRequestType,
+		DeviceIdentifier: ExtendedIdent,
+	}
+	request := &SetTableRequest{
+		MeBasePacket: MeBasePacket{
+			EntityClass:    me.OnuGClassID,
+			EntityInstance: uint16(0x0),
+			Extended:       true,
+		},
+		AttributeMask: uint16(0x1000),
+		Attributes:    me.AttributeValueMap{"TrafficManagementOption": byte(1)},
+	}
+	// Test serialization back to former string
+	var options gopacket.SerializeOptions
+	options.FixLengths = true
+
+	buffer := gopacket.NewSerializeBuffer()
+	err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
+	assert.Error(t, err)
+}
+
+func TestSetTableResponseDecode(t *testing.T) {
+	goodMessage := "01073d0b00ab1234000101"
+	data, err := stringToPacket(goodMessage)
+	assert.NoError(t, err)
+
+	packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.NoCopy)
+	assert.NotNil(t, packet)
+
+	omciLayer := packet.Layer(LayerTypeOMCI)
+	assert.NotNil(t, omciLayer)
+
+	omciMsg, ok := omciLayer.(*OMCI)
+	assert.True(t, ok)
+	assert.NotNil(t, omciMsg)
+	assert.Equal(t, LayerTypeOMCI, omciMsg.LayerType())
+	assert.Equal(t, LayerTypeOMCI, omciMsg.CanDecode())
+	assert.Equal(t, LayerTypeSetTableResponse, omciMsg.NextLayerType())
+	assert.Equal(t, uint16(0x0107), omciMsg.TransactionID)
+	assert.Equal(t, SetTableResponseType, omciMsg.MessageType)
+	assert.Equal(t, ExtendedIdent, omciMsg.DeviceIdentifier)
+	assert.Equal(t, uint16(1), omciMsg.Length)
+
+	msgLayer := packet.Layer(LayerTypeSetTableResponse)
+	assert.NotNil(t, msgLayer)
+
+	response, ok2 := msgLayer.(*SetTableResponse)
+	assert.True(t, ok2)
+	assert.NotNil(t, response)
+	assert.Equal(t, LayerTypeSetTableResponse, response.LayerType())
+	assert.Equal(t, LayerTypeSetTableResponse, response.CanDecode())
+	assert.Equal(t, gopacket.LayerTypePayload, response.NextLayerType())
+	assert.Equal(t, me.ProcessingError, response.Result)
+	assert.Equal(t, me.ExtendedVlanTaggingOperationConfigurationDataClassID, response.EntityClass)
+	assert.Equal(t, uint16(0x1234), response.EntityInstance)
+
+	// Verify string output for message
+	packetString := packet.String()
+	assert.NotZero(t, len(packetString))
+}
+
+func TestSetTableResponseSerialize(t *testing.T) {
+	goodMessage := "01073d0b00ab1234000103"
+
+	omciLayer := &OMCI{
+		TransactionID:    0x0107,
+		MessageType:      SetTableResponseType,
+		DeviceIdentifier: ExtendedIdent,
+	}
+	request := &SetTableResponse{
+		MeBasePacket: MeBasePacket{
+			EntityClass:    me.ExtendedVlanTaggingOperationConfigurationDataClassID,
+			EntityInstance: uint16(0x1234),
+			Extended:       true,
+		},
+		Result: me.ParameterError,
+	}
+	// Test serialization back to former string
+	var options gopacket.SerializeOptions
+	options.FixLengths = true
+
+	buffer := gopacket.NewSerializeBuffer()
+	err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
+	assert.NoError(t, err)
+
+	outgoingPacket := buffer.Bytes()
+	reconstituted := packetToString(outgoingPacket)
+	assert.Equal(t, strings.ToLower(goodMessage), reconstituted)
+}
+
+func TestSetTableResponseZeroTICSerialize(t *testing.T) {
+	omciLayer := &OMCI{
+		TransactionID:    0x0,
+		MessageType:      SetTableResponseType,
+		DeviceIdentifier: ExtendedIdent,
+	}
+	request := &SetTableResponse{
+		MeBasePacket: MeBasePacket{
+			EntityClass:    me.ExtendedVlanTaggingOperationConfigurationDataClassID,
+			EntityInstance: uint16(0x1234),
+			Extended:       true,
+		},
+		Result: me.ParameterError,
+	}
+	// Test serialization back to former string
+	var options gopacket.SerializeOptions
+	options.FixLengths = true
+
+	buffer := gopacket.NewSerializeBuffer()
+	err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
+	assert.Error(t, err)
+}