get_test.go

/*
 * 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 (
	"encoding/base64"
	"encoding/binary"
	"fmt"
	"github.com/google/gopacket"
	. "github.com/opencord/omci-lib-go/v2"
	me "github.com/opencord/omci-lib-go/v2/generated"
	"github.com/stretchr/testify/assert"
	"strings"
	"testing"
)

func TestGetRequestDecode(t *testing.T) {
	goodMessage := "035e490a01070000004400000000000000000000000000000000000000000000000000000000000000000028"
	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.Equal(t, LayerTypeOMCI, omciMsg.LayerType())
	assert.Equal(t, LayerTypeOMCI, omciMsg.CanDecode())
	assert.Equal(t, LayerTypeGetRequest, omciMsg.NextLayerType())
	assert.Equal(t, uint16(0x035e), omciMsg.TransactionID)
	assert.Equal(t, GetRequestType, omciMsg.MessageType)
	assert.Equal(t, BaselineIdent, omciMsg.DeviceIdentifier)
	assert.Equal(t, uint16(40), omciMsg.Length)

	msgLayer := packet.Layer(LayerTypeGetRequest)
	assert.NotNil(t, msgLayer)

	request, ok2 := msgLayer.(*GetRequest)
	assert.True(t, ok2)
	assert.NotNil(t, request)
	assert.Equal(t, LayerTypeGetRequest, request.LayerType())
	assert.Equal(t, LayerTypeGetRequest, request.CanDecode())
	assert.Equal(t, gopacket.LayerTypePayload, request.NextLayerType())

	// Verify string output for message
	packetString := packet.String()
	assert.NotZero(t, len(packetString))
}

func TestGetRequestSerialize(t *testing.T) {
	goodMessage := "035e490a01070000004400000000000000000000000000000000000000000000000000000000000000000028"

	omciLayer := &OMCI{
		TransactionID: 0x035e,
		MessageType:   GetRequestType,
		// DeviceIdentifier: omci.BaselineIdent,		// Optional, defaults to Baseline
		// Length:           0x28,						// Optional, defaults to 40 octets
	}
	request := &GetRequest{
		MeBasePacket: MeBasePacket{
			EntityClass:    me.AniGClassID,
			EntityInstance: uint16(0),
		},
		AttributeMask: uint16(0x0044),
	}
	// 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 TestGetRequestZeroTICSerialize(t *testing.T) {
	omciLayer := &OMCI{
		TransactionID: 0x0000,
		MessageType:   GetRequestType,
		// DeviceIdentifier: omci.BaselineIdent,		// Optional, defaults to Baseline
		// Length:           0x28,						// Optional, defaults to 40 octets
	}
	request := &GetRequest{
		MeBasePacket: MeBasePacket{
			EntityClass:    me.AniGClassID,
			EntityInstance: uint16(0),
		},
		AttributeMask: uint16(0x0044),
	}
	// 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 TestGetResponseDecode(t *testing.T) {
	goodMessage := "035e290a01070000000044dbcb05f10000000000000000000000000000000000000000000000000000000028"
	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.Equal(t, uint16(0x035e), omciMsg.TransactionID)
	assert.Equal(t, GetResponseType, omciMsg.MessageType)
	assert.Equal(t, BaselineIdent, omciMsg.DeviceIdentifier)
	assert.Equal(t, uint16(40), omciMsg.Length)

	msgLayer := packet.Layer(LayerTypeGetResponse)
	assert.NotNil(t, msgLayer)

	response, ok2 := msgLayer.(*GetResponse)
	assert.True(t, ok2)
	assert.NotNil(t, response)
	assert.Equal(t, LayerTypeGetResponse, response.LayerType())
	assert.Equal(t, LayerTypeGetResponse, response.CanDecode())
	assert.Equal(t, gopacket.LayerTypePayload, response.NextLayerType())
	assert.Equal(t, response.Result, me.Success)
	assert.Equal(t, response.AttributeMask, uint16(0x0044))
	assert.Equal(t, response.Attributes["TransmitOpticalLevel"], uint16(0x05f1))
	assert.Equal(t, response.Attributes["OpticalSignalLevel"], uint16(0xdbcb))

	// Verify string output for message
	packetString := packet.String()
	assert.NotZero(t, len(packetString))
}

func TestGetResponseSerialize(t *testing.T) {
	goodMessage := "035e290a01070000000044dbcb05f10000000000000000000000000000000000000000000000000000000028"

	omciLayer := &OMCI{
		TransactionID: 0x035e,
		MessageType:   GetResponseType,
		// DeviceIdentifier: omci.BaselineIdent,		// Optional, defaults to Baseline
		// Length:           0x28,						// Optional, defaults to 40 octets
	}
	request := &GetResponse{
		MeBasePacket: MeBasePacket{
			EntityClass:    me.AniGClassID,
			EntityInstance: uint16(0),
		},
		Result:        0,
		AttributeMask: uint16(0x0044),
		Attributes: me.AttributeValueMap{
			"TransmitOpticalLevel": uint16(0x05f1),
			"OpticalSignalLevel":   uint16(0xdbcb)},
	}
	// 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 TestGetResponseZeroTICSerialize(t *testing.T) {
	omciLayer := &OMCI{
		TransactionID: 0x0,
		MessageType:   GetResponseType,
		// DeviceIdentifier: omci.BaselineIdent,		// Optional, defaults to Baseline
		// Length:           0x28,						// Optional, defaults to 40 octets
	}
	request := &GetResponse{
		MeBasePacket: MeBasePacket{
			EntityClass:    me.AniGClassID,
			EntityInstance: uint16(0),
		},
		Result:        0,
		AttributeMask: uint16(0x0044),
		Attributes: me.AttributeValueMap{
			"TransmitOpticalLevel": uint16(0x05f1),
			"OpticalSignalLevel":   uint16(0xdbcb)},
	}
	// 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)
}

///////////////////////////////////////////////////////////////////////
// Packet definitions for attributes of various types/sizes
func toOctets(str string) []byte {
	data, err := base64.StdEncoding.DecodeString(str)
	if err != nil {
		panic(fmt.Sprintf("Invalid Base-64 string: '%v'", str))
	}
	return data
}

func TestGetResponseSerializeTruncationFailure(t *testing.T) {
	// Too much data and 'fix-length' is not specified.  This response has 26
	// octets in the requested data, but only 25 octets available

	omciLayer := &OMCI{
		TransactionID: 0x035e,
		MessageType:   GetResponseType,
		// DeviceIdentifier: omci.BaselineIdent,		// Optional, defaults to Baseline
		// Length:           0x28,						// Optional, defaults to 40 octets
	}
	request := &GetResponse{
		MeBasePacket: MeBasePacket{
			EntityClass:    me.OnuGClassID,
			EntityInstance: uint16(0),
		},
		Result:        0,
		AttributeMask: uint16(0xE000),
		Attributes: me.AttributeValueMap{
			"VendorId":     toOctets("ICAgIA=="),
			"Version":      toOctets("MAAAAAAAAAAAAAAAAAA="),
			"SerialNumber": toOctets("AAAAAAAAAAA="),
		},
	}
	// Test serialization and verify truncation failure
	var options gopacket.SerializeOptions
	options.FixLengths = false

	buffer := gopacket.NewSerializeBuffer()
	err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
	assert.Error(t, err)
	assert.IsType(t, &me.MessageTruncatedError{}, err)
}

func TestGetResponseSerializeTruncationButOkay(t *testing.T) {
	// Too much data and 'fix-length' is specified so it packs as much as
	// possible and adjusts the failure masks

	omciLayer := &OMCI{
		TransactionID: 0x035e,
		MessageType:   GetResponseType,
		// DeviceIdentifier: omci.BaselineIdent,		// Optional, defaults to Baseline
		// Length:           0x28,						// Optional, defaults to 40 octets
	}
	response := &GetResponse{
		MeBasePacket: MeBasePacket{
			EntityClass:    me.OnuGClassID,
			EntityInstance: uint16(0),
		},
		Result:        0,
		AttributeMask: uint16(0xE000),
		Attributes: me.AttributeValueMap{
			"VendorId":     toOctets("ICAgIA=="),
			"Version":      toOctets("MAAAAAAAAAAAAAAAAAA="),
			"SerialNumber": toOctets("AAAAAAAAAAA="),
		},
	}
	// Test serialization and verify truncation failure
	var options gopacket.SerializeOptions
	options.FixLengths = true

	buffer := gopacket.NewSerializeBuffer()
	err := gopacket.SerializeLayers(buffer, options, omciLayer, response)
	assert.NoError(t, err)

	// Now deserialize it and see if we have the proper result (Attribute Failure)
	// and a non-zero failed mask
	responsePacket := buffer.Bytes()
	packet := gopacket.NewPacket(responsePacket, LayerTypeOMCI, gopacket.NoCopy)
	assert.NotNil(t, packet)

	omciLayer2 := packet.Layer(LayerTypeOMCI)
	assert.NotNil(t, omciLayer2)

	omciMsg2, ok := omciLayer2.(*OMCI)
	assert.True(t, ok)
	assert.Equal(t, LayerTypeOMCI, omciMsg2.LayerType())
	assert.Equal(t, LayerTypeOMCI, omciMsg2.CanDecode())
	assert.Equal(t, LayerTypeGetResponse, omciMsg2.NextLayerType())
	assert.Equal(t, omciMsg2.TransactionID, omciLayer.TransactionID)
	assert.Equal(t, GetResponseType, omciLayer.MessageType)
	assert.Equal(t, BaselineIdent, omciLayer.DeviceIdentifier)
	assert.Equal(t, uint16(40), omciLayer.Length)

	msgLayer2 := packet.Layer(LayerTypeGetResponse)
	assert.NotNil(t, msgLayer2)

	response2, ok2 := msgLayer2.(*GetResponse)
	assert.True(t, ok2)
	assert.NotNil(t, response2)
	assert.Equal(t, LayerTypeGetResponse, response2.LayerType())
	assert.Equal(t, LayerTypeGetResponse, response2.CanDecode())
	assert.Equal(t, gopacket.LayerTypePayload, response2.NextLayerType())
	assert.Equal(t, me.AttributeFailure, response2.Result)
	assert.NotZero(t, response2.AttributeMask)
	assert.NotZero(t, response2.FailedAttributeMask)
	assert.Zero(t, response2.UnsupportedAttributeMask)
}

func TestGetResponseTableFailedAttributesDecode(t *testing.T) {
	// This is a GET Response with failed and unsupported attributes
	// TODO:Implement
}

func TestGetResponseTableFailedAttributesSerialize(t *testing.T) {
	// This is a GET Response with failed and unsupported attributes
	// TODO:Implement
}

func TestGetResponseTableAttributeDecode(t *testing.T) {
	// This is a GET Response for a table attribute. It should return the attribute
	// size as a uint16.
	// TODO:Implement
}

func TestGetResponseTableAttributeSerialize(t *testing.T) {
	// This is a GET Response for a table attribute. It should return the attribute
	// size as a uint16.
	// TODO:Implement
}

func TestExtendedGetRequestDecode(t *testing.T) {
	//ONU-2G: 257
	goodMessage := "035e490b010100000002fffc"
	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, LayerTypeGetRequest, omciMsg.NextLayerType())
	assert.Equal(t, uint16(0x035e), omciMsg.TransactionID)
	assert.Equal(t, GetRequestType, omciMsg.MessageType)
	assert.Equal(t, ExtendedIdent, omciMsg.DeviceIdentifier)
	assert.Equal(t, uint16(2), omciMsg.Length)

	msgLayer := packet.Layer(LayerTypeGetRequest)
	assert.NotNil(t, msgLayer)

	request, ok2 := msgLayer.(*GetRequest)
	assert.True(t, ok2)
	assert.NotNil(t, request)
	assert.Equal(t, LayerTypeGetRequest, request.LayerType())
	assert.Equal(t, LayerTypeGetRequest, request.CanDecode())
	assert.Equal(t, gopacket.LayerTypePayload, request.NextLayerType())

	//ONU-2G: 257
	assert.Equal(t, me.Onu2GClassID, request.EntityClass)
	assert.Equal(t, uint16(0), request.EntityInstance)
	assert.Equal(t, uint16(0xfffc), request.AttributeMask)

	// Verify string output for message
	packetString := packet.String()
	assert.NotZero(t, len(packetString))
}

func TestExtendedGetRequestDecodeTruncated(t *testing.T) {
	goodMessage := "035e490b010100000002ff"
	data, err := stringToPacket(goodMessage)
	assert.NoError(t, err)

	packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.NoCopy)
	assert.NotNil(t, packet)

	failure := packet.ErrorLayer()
	assert.NotNil(t, failure)

	decodeFailure, ok := failure.(*gopacket.DecodeFailure)
	assert.NotNil(t, decodeFailure)
	assert.True(t, ok)
	assert.NotNil(t, decodeFailure.String())
	assert.True(t, len(decodeFailure.String()) > 0)

	metadata := packet.Metadata()
	assert.NotNil(t, metadata)
	assert.True(t, metadata.Truncated)

	// Verify string output for message
	packetString := packet.String()
	assert.NotZero(t, len(packetString))
}

func TestExtendedGetRequestSerialize(t *testing.T) {
	goodMessage := "035e490b010100000002fffc"

	omciLayer := &OMCI{
		TransactionID:    0x035e,
		MessageType:      GetRequestType,
		DeviceIdentifier: ExtendedIdent,
		// Length parameter is optional for Extended message format serialization
		// and if present it will be overwritten during the serialization with the
		// actual value.
	}
	request := &GetRequest{
		MeBasePacket: MeBasePacket{
			EntityClass:    me.Onu2GClassID,
			EntityInstance: uint16(0),
			Extended:       true,
		},
		AttributeMask: uint16(0xfffc),
	}
	// 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 TestExtendedGetResponseDecode(t *testing.T) {
	attrDef, omciErr := me.GetAttributesDefinitions(me.Onu2GClassID)
	assert.NotNil(t, attrDef)
	assert.NotNil(t, omciErr)
	assert.Equal(t, me.Success, omciErr.StatusCode())

	attributes := []interface{}{
		toOctets("AAAAAAAAAAAAAAAAAAAAAAAAAAA="), //  1: MultiByteField - "EquipmentId"  (20 zeros)
		byte(0xb4),                               //  2: ByteField   - "OpticalNetworkUnitManagementAndControlChannelOmccVersion"
		uint16(0x1234),                           //  3: Uint16Field - "VendorProductCode"
		byte(1),                                  //  4: ByteField   - "SecurityCapability"
		byte(1),                                  //  5: ByteField   - "SecurityMode"
		uint16(0x5678),                           //  6: Uint16Field - "TotalPriorityQueueNumber"
		byte(0x44),                               //  7: ByteField   - "TotalTrafficSchedulerNumber"
		byte(1),                                  //  8: ByteField   - "Deprecated"
		uint16(0x55aa),                           //  9: Uint16Field - "TotalGemPortIdNumber"
		uint32(0xC4108011),                       // 10: Uint32Field - "Sysuptime"
		uint16(0x6),                              // 11: Uint16Field - "ConnectivityCapability"
		byte(6),                                  // 12: ByteField   - "CurrentConnectivityMode"
		uint16(2),                                // 13: Uint16Field - "QualityOfServiceQosConfigurationFlexibility"
		uint16(0x1234),                           // 14: Uint16Field - "PriorityQueueScaleFactor"
	}
	attributeData := make([]byte, 0)

	// Walk through all attributes and encode them
	for _, value := range attributes {
		//attrDef, err := meDef.GetAttributeByIndex(index)
		var buf []byte
		u8, ok := value.(byte)
		if ok {
			buf = []byte{u8}
		} else {
			u16, ok := value.(uint16)
			if ok {
				buf = make([]byte, 2)
				binary.BigEndian.PutUint16(buf, u16)
			} else {
				u32, ok := value.(uint32)
				if ok {
					buf = make([]byte, 4)
					binary.BigEndian.PutUint32(buf, u32)
				} else {
					bytes, ok := value.([]byte)
					if ok {
						buf = bytes
					} else {
						assert.True(t, false) // Unknown attribute type
					}
				}
			}
		}
		attributeData = append(attributeData, buf...)
	}
	attributeMask := 0xfffc
	msgLength := len(attributeData) + 7
	// Results is 0 ("00"), and the two optional attribute masks are 0 ("00000000") as well
	goodMessage := "035e290b01010000" + fmt.Sprintf("%04x", msgLength) +
		"00" + fmt.Sprintf("%04x", attributeMask) + "00000000" + packetToString(attributeData)

	data, err := stringToPacket(goodMessage)
	assert.NotNil(t, data)
	assert.Nil(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, LayerTypeGetResponse, omciMsg.NextLayerType())
	assert.Equal(t, uint16(0x035e), omciMsg.TransactionID)
	assert.Equal(t, GetResponseType, omciMsg.MessageType)
	assert.Equal(t, ExtendedIdent, omciMsg.DeviceIdentifier)
	assert.Equal(t, uint16(msgLength), omciMsg.Length)

	msgLayer := packet.Layer(LayerTypeGetResponse)
	assert.NotNil(t, msgLayer)

	response, ok2 := msgLayer.(*GetResponse)
	assert.True(t, ok2)
	assert.NotNil(t, response)
	assert.Equal(t, LayerTypeGetResponse, response.LayerType())
	assert.Equal(t, LayerTypeGetResponse, response.CanDecode())
	assert.Equal(t, gopacket.LayerTypePayload, response.NextLayerType())
	assert.Equal(t, me.Success, response.Result)
	assert.Equal(t, uint16(attributeMask), response.AttributeMask)
	assert.Equal(t, uint16(0), response.FailedAttributeMask)
	assert.Equal(t, uint16(0), response.UnsupportedAttributeMask)

	assert.Equal(t, toOctets("AAAAAAAAAAAAAAAAAAAAAAAAAAA="), response.Attributes["EquipmentId"])
	assert.Equal(t, byte(0xb4), response.Attributes["OpticalNetworkUnitManagementAndControlChannelOmccVersion"])
	assert.Equal(t, uint16(0x1234), response.Attributes["VendorProductCode"])
	assert.Equal(t, byte(1), response.Attributes["SecurityCapability"])
	assert.Equal(t, byte(1), response.Attributes["SecurityMode"])
	assert.Equal(t, uint16(0x5678), response.Attributes["TotalPriorityQueueNumber"])
	assert.Equal(t, byte(0x44), response.Attributes["TotalTrafficSchedulerNumber"])
	assert.Equal(t, byte(1), response.Attributes["Deprecated"])
	assert.Equal(t, uint16(0x55aa), response.Attributes["TotalGemPortIdNumber"])
	assert.Equal(t, uint32(0xC4108011), response.Attributes["Sysuptime"])
	assert.Equal(t, uint16(0x6), response.Attributes["ConnectivityCapability"])
	assert.Equal(t, byte(6), response.Attributes["CurrentConnectivityMode"])
	assert.Equal(t, uint16(2), response.Attributes["QualityOfServiceQosConfigurationFlexibility"])
	assert.Equal(t, uint16(0x1234), response.Attributes["PriorityQueueScaleFactor"])

	// Verify string output for message
	packetString := packet.String()
	assert.NotZero(t, len(packetString))
}

func TestExtendedGetResponseSerialize(t *testing.T) {
	goodMessage := "035e290b01010000003100fffc" +
		"000000000000000000000000000000000000000000000000" +
		"b4123401015678440155aac410801100060600021234"

	omciLayer := &OMCI{
		TransactionID:    0x035e,
		MessageType:      GetResponseType,
		DeviceIdentifier: ExtendedIdent,
		// Length parameter is optional for Extended message format serialization
		// and if present it will be overwritten during the serialization with the
		// actual value.
	}
	request := &GetResponse{
		MeBasePacket: MeBasePacket{
			EntityClass:    me.Onu2GClassID,
			EntityInstance: uint16(0),
			Extended:       true,
		},
		Result:        0,
		AttributeMask: uint16(0xfffc),
		Attributes: me.AttributeValueMap{
			"EquipmentId": toOctets("AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"OpticalNetworkUnitManagementAndControlChannelOmccVersion": byte(0xb4),
			"VendorProductCode":                           uint16(0x1234),
			"SecurityCapability":                          byte(1),
			"SecurityMode":                                byte(1),
			"TotalPriorityQueueNumber":                    uint16(0x5678),
			"TotalTrafficSchedulerNumber":                 byte(0x44),
			"Deprecated":                                  byte(1),
			"TotalGemPortIdNumber":                        uint16(0x55aa),
			"Sysuptime":                                   uint32(0xC4108011),
			"ConnectivityCapability":                      uint16(0x6),
			"CurrentConnectivityMode":                     byte(6),
			"QualityOfServiceQosConfigurationFlexibility": uint16(2),
			"PriorityQueueScaleFactor":                    uint16(0x1234),
		},
	}
	// 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)
}