VOL-4143: Implementation of missing decode/serialize of baseline Get Current Data message type
Change-Id: I56605b7d75d70f8bf36c220b3b90b8f1f25745d0
diff --git a/messagetypes_test.go b/messagetypes_test.go
index 5420e99..30672c6 100644
--- a/messagetypes_test.go
+++ b/messagetypes_test.go
@@ -2740,8 +2740,7 @@
assert.Equal(t, strings.ToLower(goodMessage), reconstituted)
}
-// TODO: Create request/response tests for all of the following types//GetCurrentData,
-//SetTable}
+// TODO: Create request/response tests for all of the following types -> SetTable
func TestAlarmNotificationDecode(t *testing.T) {
goodMessage := "0000100a000b0104800000000000000000000000000000000000000000000000000000000000000500000028"
@@ -4404,5 +4403,138 @@
assert.Equal(t, strings.ToLower(goodMessage), reconstituted)
}
+func TestGetCurrentDataRequestDecode(t *testing.T) {
+ goodMessage := "035e5c0a01aa0000004400000000000000000000000000000000000000000000000000000000000000000028"
+ 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, GetCurrentDataRequestType, omciMsg.MessageType)
+ assert.Equal(t, BaselineIdent, omciMsg.DeviceIdentifier)
+ assert.Equal(t, uint16(40), omciMsg.Length)
+
+ msgLayer := packet.Layer(LayerTypeGetCurrentDataRequest)
+ assert.NotNil(t, msgLayer)
+
+ request, ok2 := msgLayer.(*GetCurrentDataRequest)
+ assert.True(t, ok2)
+ assert.NotNil(t, request)
+ assert.Equal(t, me.EthernetFrameExtendedPm64BitClassID, request.EntityClass)
+ assert.Equal(t, uint16(0), request.EntityInstance)
+ assert.Equal(t, uint16(0x0044), request.AttributeMask)
+
+ // Verify string output for message
+ packetString := packet.String()
+ assert.NotZero(t, len(packetString))
+}
+
+func TestGetCurrentDataRequestSerialize(t *testing.T) {
+ goodMessage := "035e5c0a01aa0000004400000000000000000000000000000000000000000000000000000000000000000028"
+
+ omciLayer := &OMCI{
+ TransactionID: 0x035e,
+ MessageType: GetCurrentDataRequestType,
+ // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
+ // Length: 0x28, // Optional, defaults to 40 octets
+ }
+ request := &GetCurrentDataRequest{
+ MeBasePacket: MeBasePacket{
+ EntityClass: me.EthernetFrameExtendedPm64BitClassID,
+ 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 TestGetCurrentDataResponseDecode(t *testing.T) {
+ goodMessage := "035e3c0a01aa0000000044123456781234dbcb432187654321dac1000000000000000000000000000028"
+ 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, GetCurrentDataResponseType, omciMsg.MessageType)
+ assert.Equal(t, BaselineIdent, omciMsg.DeviceIdentifier)
+ assert.Equal(t, uint16(40), omciMsg.Length)
+
+ msgLayer := packet.Layer(LayerTypeGetCurrentDataResponse)
+ assert.NotNil(t, msgLayer)
+
+ response, ok2 := msgLayer.(*GetCurrentDataResponse)
+ assert.True(t, ok2)
+ assert.NotNil(t, response)
+ assert.Equal(t, me.EthernetFrameExtendedPm64BitClassID, response.EntityClass)
+ assert.Equal(t, uint16(0), response.EntityInstance)
+ assert.Equal(t, me.Success, response.Result)
+ assert.Equal(t, uint16(0x0044), response.AttributeMask)
+ assert.Equal(t, uint64(0x123456781234dbcb), response.Attributes["OversizeFrames"])
+ assert.Equal(t, uint64(0x432187654321dac1), response.Attributes["Frames256To511Octets"])
+
+ // Verify string output for message
+ packetString := packet.String()
+ assert.NotZero(t, len(packetString))
+}
+
+func TestGetCurrentDataResponseSerialize(t *testing.T) {
+ goodMessage := "035e3c0a01aa0000000044123456781234dbcb432187654321dac10000000000000000000000000000000028"
+
+ omciLayer := &OMCI{
+ TransactionID: 0x035e,
+ MessageType: GetCurrentDataResponseType,
+ // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
+ // Length: 0x28, // Optional, defaults to 40 octets
+ }
+ request := &GetCurrentDataResponse{
+ MeBasePacket: MeBasePacket{
+ EntityClass: me.EthernetFrameExtendedPm64BitClassID,
+ EntityInstance: uint16(0),
+ },
+ Result: 0,
+ AttributeMask: uint16(0x0044),
+ Attributes: me.AttributeValueMap{
+ "OversizeFrames": uint64(0x123456781234dbcb),
+ "Frames256To511Octets": uint64(0x432187654321dac1),
+ // BroadcastFrames can be supplied but will not be encoded since not in attribute mask.
+ "BroadcastFrames": uint64(0x0123456789abcdef)},
+ }
+ // 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)
+}
+
// TODO: Also remember to add extended message tests to the meframe_test.go
// unit tests as more message types are supported