VOL-4337: Code upgrade for 3/2020 G.988 support and remaining Extended Message Set support
Change-Id: I6c5e1a167216ad9b51e9da89460e9909465ae1bc
diff --git a/test_test.go b/test_test.go
new file mode 100644
index 0000000..b387428
--- /dev/null
+++ b/test_test.go
@@ -0,0 +1,691 @@
+/*
+ * 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 (
+ "fmt"
+ "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 TestGenericTestResultDecode(t *testing.T) {
+ // ONU-G ME for this test with just made up data
+ payload := "1234567890123456789012345678901234567890123456789012345678901234"
+ goodMessage := "00001b0a01000000" + payload + "00000028"
+ 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, LayerTypeTestResult, omciMsg.NextLayerType())
+ assert.Equal(t, uint16(0x0000), omciMsg.TransactionID)
+ assert.Equal(t, TestResultType, omciMsg.MessageType)
+ assert.Equal(t, BaselineIdent, omciMsg.DeviceIdentifier)
+ assert.Equal(t, uint16(40), omciMsg.Length)
+
+ msgLayer := packet.Layer(LayerTypeTestResult)
+ assert.NotNil(t, msgLayer)
+
+ // This is a generic struct since we do not do detailed decode
+ generic, ok2 := msgLayer.(*TestResultNotification)
+ assert.True(t, ok2)
+ assert.NotNil(t, generic)
+ assert.Equal(t, LayerTypeTestResult, generic.LayerType())
+ assert.Equal(t, LayerTypeTestResult, generic.CanDecode())
+ assert.Equal(t, gopacket.LayerTypePayload, generic.NextLayerType())
+ assert.NotNil(t, generic.MeBasePacket.Payload) // Next three all same data
+ assert.NotNil(t, generic.Payload)
+ assert.NotNil(t, generic.TestResults())
+
+ base := generic.MeBasePacket
+ assert.Equal(t, me.OnuGClassID, base.EntityClass)
+ assert.Equal(t, uint16(0), base.EntityInstance)
+
+ // For the generic Test Result, get the payload data which is all the data in
+ // the test notification past the Entity Instance value.
+ payloadData, payloadErr := stringToPacket(payload)
+ assert.NotNil(t, payloadData)
+ assert.NoError(t, payloadErr)
+ assert.Equal(t, payloadData, base.Payload)
+ assert.Equal(t, payloadData, generic.Payload)
+
+ // Verify string output for message
+ packetString := packet.String()
+ assert.NotZero(t, len(packetString))
+}
+
+func TestOpticalLineSupervisionTestResultDecode(t *testing.T) {
+ // ANI-G ME for this test with just made up data
+ payload := "010034" + "030067" + "050091" + "090034" + "0c0067" + "8901" + "000000000000000000000000000000"
+ goodMessage := "00001b0a01078001" + payload + "00000028"
+ 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, LayerTypeTestResult, omciMsg.NextLayerType())
+ assert.Equal(t, uint16(0x0000), omciMsg.TransactionID)
+ assert.Equal(t, TestResultType, omciMsg.MessageType)
+ assert.Equal(t, BaselineIdent, omciMsg.DeviceIdentifier)
+ assert.Equal(t, uint16(40), omciMsg.Length)
+
+ msgLayer := packet.Layer(LayerTypeTestResult)
+ assert.NotNil(t, msgLayer)
+
+ // This is a optical line test results
+ optical, ok2 := msgLayer.(*OpticalLineSupervisionTestResult)
+ assert.True(t, ok2)
+ assert.NotNil(t, optical)
+ assert.Equal(t, LayerTypeTestResult, optical.LayerType())
+ assert.Equal(t, LayerTypeTestResult, optical.CanDecode())
+ assert.Equal(t, gopacket.LayerTypePayload, optical.NextLayerType())
+
+ // Get the Managed Entity class ID and instance ID from the base packet
+ base := optical.MeBasePacket
+ assert.Equal(t, me.AniGClassID, base.EntityClass)
+ assert.Equal(t, uint16(0x8001), base.EntityInstance)
+
+ assert.Equal(t, uint8(1), optical.PowerFeedVoltageType)
+ assert.Equal(t, uint16(0x34), optical.PowerFeedVoltage)
+
+ assert.Equal(t, uint8(3), optical.ReceivedOpticalPowerType)
+ assert.Equal(t, uint16(0x67), optical.ReceivedOpticalPower)
+
+ assert.Equal(t, uint8(5), optical.MeanOpticalLaunchType)
+ assert.Equal(t, uint16(0x91), optical.MeanOpticalLaunch)
+
+ assert.Equal(t, uint8(9), optical.LaserBiasCurrentType)
+ assert.Equal(t, uint16(0x34), optical.LaserBiasCurrent)
+
+ assert.Equal(t, uint8(12), optical.TemperatureType)
+ assert.Equal(t, uint16(0x67), optical.Temperature)
+
+ assert.Equal(t, uint16(0x8901), optical.GeneralPurposeBuffer)
+
+ // Verify string output for message
+ packetString := packet.String()
+ assert.NotZero(t, len(packetString))
+}
+
+func TestGenericTestResultSerialize(t *testing.T) {
+ payload := "1234567891234567890123456789012345678901234567890123456789012345"
+ goodMessage := "00001b0a01000000" + payload + "00000028"
+
+ omciLayer := &OMCI{
+ TransactionID: 0x0000, // Optional for notifications since TID always 0x0000
+ MessageType: TestResultType,
+ // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
+ // Length: 0x28, // Optional, defaults to 40 octets
+ }
+ data, derr := stringToPacket(payload)
+ assert.NoError(t, derr)
+
+ request := &TestResultNotification{
+ MeBasePacket: MeBasePacket{
+ EntityClass: me.OnuGClassID,
+ EntityInstance: uint16(0),
+ },
+ Payload: data,
+ }
+ // 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 TestGenericTestResultNonZeroTICSerialize(t *testing.T) {
+ payload := "1234567891234567890123456789012345678901234567890123456789012345"
+ goodMessage := "12341b0a01000000" + payload + "00000028"
+
+ omciLayer := &OMCI{
+ TransactionID: 0x1234,
+ MessageType: TestResultType,
+ // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
+ // Length: 0x28, // Optional, defaults to 40 octets
+ }
+ data, derr := stringToPacket(payload)
+ assert.NoError(t, derr)
+
+ request := &TestResultNotification{
+ MeBasePacket: MeBasePacket{
+ EntityClass: me.OnuGClassID,
+ EntityInstance: uint16(0),
+ },
+ Payload: data,
+ }
+ // 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 TestOpticalLineSupervisionTestResultSerialize(t *testing.T) {
+ // ANI-G ME for this test with just made up data
+ payload := "010034" + "030067" + "050091" + "090034" + "0c0067" + "8901" + "000000000000000000000000000000"
+ goodMessage := "00001b0a01078001" + payload + "00000028"
+
+ omciLayer := &OMCI{
+ // TransactionID: 0x0c, // Optional for notifications since TID always 0x0000
+ MessageType: TestResultType,
+ // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
+ // Length: 0x28, // Optional, defaults to 40 octets
+ }
+ request := &OpticalLineSupervisionTestResult{
+ MeBasePacket: MeBasePacket{
+ EntityClass: me.AniGClassID,
+ EntityInstance: uint16(0x8001),
+ },
+ PowerFeedVoltageType: uint8(1),
+ PowerFeedVoltage: uint16(0x34),
+ ReceivedOpticalPowerType: uint8(3),
+ ReceivedOpticalPower: uint16(0x67),
+ MeanOpticalLaunchType: uint8(5),
+ MeanOpticalLaunch: uint16(0x91),
+ LaserBiasCurrentType: uint8(9),
+ LaserBiasCurrent: uint16(0x34),
+ TemperatureType: uint8(12),
+ Temperature: uint16(0x67),
+ GeneralPurposeBuffer: uint16(0x8901),
+ }
+ // 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 TestGenericTestRequestDecode(t *testing.T) {
+ // ONU-G ME for this test with just made up data
+ payload := "1234567890523456789012345678901234567890123456789012345678901234"
+ goodMessage := "0123520a01000000" + payload + "00000028"
+ 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, LayerTypeTestRequest, omciMsg.NextLayerType())
+ assert.Equal(t, uint16(0x0123), omciMsg.TransactionID)
+ assert.Equal(t, TestRequestType, omciMsg.MessageType)
+ assert.Equal(t, BaselineIdent, omciMsg.DeviceIdentifier)
+ assert.Equal(t, uint16(40), omciMsg.Length)
+
+ msgLayer := packet.Layer(LayerTypeTestRequest)
+ assert.NotNil(t, msgLayer)
+
+ // This is a generic struct since we do not do detailed decode
+ generic, ok2 := msgLayer.(*TestRequest)
+ assert.True(t, ok2)
+ assert.NotNil(t, generic)
+ assert.Equal(t, LayerTypeTestRequest, generic.LayerType())
+ assert.Equal(t, LayerTypeTestRequest, generic.CanDecode())
+ assert.Equal(t, gopacket.LayerTypePayload, generic.NextLayerType())
+ assert.NotNil(t, generic.MeBasePacket.Payload) // Next three all same data
+ assert.NotNil(t, generic.Payload)
+ assert.NotNil(t, generic.TestRequest())
+
+ base := generic.MeBasePacket
+ assert.Equal(t, me.OnuGClassID, base.EntityClass)
+ assert.Equal(t, uint16(0), base.EntityInstance)
+
+ // For the generic Test Result, get the payload data which is all the data in
+ // the test notification past the Entity Instance value.
+ payloadData, payloadErr := stringToPacket(payload)
+ assert.NotNil(t, payloadData)
+ assert.NoError(t, payloadErr)
+ assert.Equal(t, payloadData, base.Payload)
+ assert.Equal(t, payloadData, generic.Payload)
+
+ // Verify string output for message
+ packetString := packet.String()
+ assert.NotZero(t, len(packetString))
+}
+
+func TestOpticalLineSupervisionTestRequestDecode(t *testing.T) {
+ // ANI-G ME for this test with just made up data
+ payload := "01" + "1234" + "5678" + "000000000000000000000000000000000000000000000000000000"
+ goodMessage := "0ddd520a01078001" + payload + "00000028"
+ 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, LayerTypeTestRequest, omciMsg.NextLayerType())
+ assert.Equal(t, uint16(0x0ddd), omciMsg.TransactionID)
+ assert.Equal(t, TestRequestType, omciMsg.MessageType)
+ assert.Equal(t, BaselineIdent, omciMsg.DeviceIdentifier)
+ assert.Equal(t, uint16(40), omciMsg.Length)
+
+ msgLayer := packet.Layer(LayerTypeTestRequest)
+ assert.NotNil(t, msgLayer)
+
+ // This is a optical line test results
+ optical, ok2 := msgLayer.(*OpticalLineSupervisionTestRequest)
+ assert.True(t, ok2)
+ assert.NotNil(t, optical)
+ assert.Equal(t, LayerTypeTestRequest, optical.LayerType())
+ assert.Equal(t, LayerTypeTestRequest, optical.CanDecode())
+ assert.Equal(t, gopacket.LayerTypePayload, optical.NextLayerType())
+
+ // Get the Managed Entity class ID and instance ID from the base packet
+ base := optical.MeBasePacket
+ assert.Equal(t, me.AniGClassID, base.EntityClass)
+ assert.Equal(t, uint16(0x8001), base.EntityInstance)
+
+ assert.Equal(t, uint8(1), optical.SelectTest)
+ assert.Equal(t, uint16(0x1234), optical.GeneralPurposeBuffer)
+ assert.Equal(t, uint16(0x5678), optical.VendorSpecificParameters)
+
+ // Verify string output for message
+ packetString := packet.String()
+ assert.NotZero(t, len(packetString))
+}
+
+func TestGenericTestRequestSerialize(t *testing.T) {
+ payload := "1234567891234567890123456789012345678901234567890123456789012345"
+ goodMessage := "eeee520a01000000" + payload + "00000028"
+
+ omciLayer := &OMCI{
+ TransactionID: 0xeeee,
+ MessageType: TestRequestType,
+ // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
+ // Length: 0x28, // Optional, defaults to 40 octets
+ }
+ data, derr := stringToPacket(payload)
+ assert.NoError(t, derr)
+
+ request := &TestRequest{
+ MeBasePacket: MeBasePacket{
+ EntityClass: me.OnuGClassID,
+ EntityInstance: uint16(0),
+ },
+ Payload: data,
+ }
+ // 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 TestOpticalLineSupervisionTestRequestSerialize(t *testing.T) {
+ // ANI-G ME for this test with just made up data
+ payload := "01" + "1234" + "5678" + "000000000000000000000000000000000000000000000000000000"
+ goodMessage := "bbbb520a01078001" + payload + "00000028"
+
+ omciLayer := &OMCI{
+ TransactionID: 0xbbbb,
+ MessageType: TestRequestType,
+ // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
+ // Length: 0x28, // Optional, defaults to 40 octets
+ }
+ request := &OpticalLineSupervisionTestRequest{
+ MeBasePacket: MeBasePacket{
+ EntityClass: me.AniGClassID,
+ EntityInstance: uint16(0x8001),
+ },
+ SelectTest: uint8(1),
+ GeneralPurposeBuffer: uint16(0x1234),
+ VendorSpecificParameters: uint16(0x5678),
+ }
+ // 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 TestTestResponseDecode(t *testing.T) {
+ goodMessage := "0001320A01000000000000000000000000000000000000000000000000000000000000000000000000000028"
+ 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, LayerTypeTestResponse, omciMsg.NextLayerType())
+ assert.Equal(t, TestResponseType, omciMsg.MessageType)
+ assert.Equal(t, uint16(40), omciMsg.Length)
+
+ msgLayer := packet.Layer(LayerTypeTestResponse)
+
+ assert.NotNil(t, msgLayer)
+
+ response, ok2 := msgLayer.(*TestResponse)
+ assert.True(t, ok2)
+ assert.NotNil(t, response)
+ assert.Equal(t, LayerTypeTestResponse, response.LayerType())
+ assert.Equal(t, LayerTypeTestResponse, response.CanDecode())
+ assert.Equal(t, gopacket.LayerTypePayload, response.NextLayerType())
+ assert.Equal(t, me.OnuGClassID, response.EntityClass)
+ assert.Equal(t, uint16(0), response.EntityInstance)
+ assert.Equal(t, me.Success, response.Result)
+
+ // Verify string output for message
+ packetString := packet.String()
+ assert.NotZero(t, len(packetString))
+}
+
+func TestTestResponseSerialize(t *testing.T) {
+ goodMessage := "0001320A01000000000000000000000000000000000000000000000000000000000000000000000000000028"
+
+ omciLayer := &OMCI{
+ TransactionID: 0x01,
+ MessageType: TestResponseType,
+ // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
+ // Length: 0x28, // Optional, defaults to 40 octets
+ }
+ request := &TestResponse{
+ MeBasePacket: MeBasePacket{
+ EntityClass: me.OnuGClassID,
+ // Default Instance ID is 0
+ },
+ Result: me.Success,
+ }
+ // 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 TestExtendedGenericTestResultDecode(t *testing.T) {
+ // ONU-G ME for this test with just made up data
+ payload := "1234567890123456789012345678901234567890"
+ resultLen := len(payload) / 2
+ goodMessage := "00001b0b01000000" + fmt.Sprintf("%04x", resultLen) + payload
+ 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, LayerTypeTestResult, omciMsg.NextLayerType())
+ assert.Equal(t, uint16(0x0000), omciMsg.TransactionID)
+ assert.Equal(t, TestResultType, omciMsg.MessageType)
+ assert.Equal(t, ExtendedIdent, omciMsg.DeviceIdentifier)
+ assert.Equal(t, omciMsg.Length, uint16(resultLen))
+
+ msgLayer := packet.Layer(LayerTypeTestResult)
+ assert.NotNil(t, msgLayer)
+
+ // This is a generic struct since we do not do detailed decode
+ generic, ok2 := msgLayer.(*TestResultNotification)
+ assert.True(t, ok2)
+ assert.NotNil(t, generic)
+ assert.Equal(t, LayerTypeTestResult, generic.LayerType())
+ assert.Equal(t, LayerTypeTestResult, generic.CanDecode())
+ assert.Equal(t, gopacket.LayerTypePayload, generic.NextLayerType())
+ assert.NotNil(t, generic.MeBasePacket.Payload) // Next three all same data
+ assert.NotNil(t, generic.Payload)
+ assert.NotNil(t, generic.TestResults())
+
+ base := generic.MeBasePacket
+ assert.Equal(t, me.OnuGClassID, base.EntityClass)
+ assert.Equal(t, uint16(0), base.EntityInstance)
+
+ // For the generic Test Result, get the payload data which is all the data in
+ // the test notification past the Entity Instance value.
+ payloadData, payloadErr := stringToPacket(payload)
+ assert.NotNil(t, payloadData)
+ assert.NoError(t, payloadErr)
+ assert.Equal(t, payloadData, base.Payload)
+ assert.Equal(t, payloadData, generic.Payload)
+
+ // Verify string output for message
+ packetString := packet.String()
+ assert.NotZero(t, len(packetString))
+}
+
+func TestExtendedOpticalLineSupervisionTestResultDecode(t *testing.T) {
+ // ANI-G ME for this test with just made up data
+ payload := "010034" + "030067" + "050091" + "090034" + "0c0067" + "8901"
+ resultLen := len(payload) / 2
+ goodMessage := "00001b0b01078001" + fmt.Sprintf("%04x", resultLen) + payload
+ 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, LayerTypeTestResult, omciMsg.NextLayerType())
+ assert.Equal(t, uint16(0x0000), omciMsg.TransactionID)
+ assert.Equal(t, TestResultType, omciMsg.MessageType)
+ assert.Equal(t, ExtendedIdent, omciMsg.DeviceIdentifier)
+ assert.Equal(t, uint16(resultLen), omciMsg.Length)
+
+ msgLayer := packet.Layer(LayerTypeTestResult)
+ assert.NotNil(t, msgLayer)
+
+ // This is a optical line test results
+ optical, ok2 := msgLayer.(*OpticalLineSupervisionTestResult)
+ assert.True(t, ok2)
+ assert.NotNil(t, optical)
+ assert.Equal(t, LayerTypeTestResult, optical.LayerType())
+ assert.Equal(t, LayerTypeTestResult, optical.CanDecode())
+ assert.Equal(t, gopacket.LayerTypePayload, optical.NextLayerType())
+
+ // Get the Managed Entity class ID and instance ID from the base packet
+ base := optical.MeBasePacket
+ assert.Equal(t, me.AniGClassID, base.EntityClass)
+ assert.Equal(t, uint16(0x8001), base.EntityInstance)
+
+ assert.Equal(t, uint8(1), optical.PowerFeedVoltageType)
+ assert.Equal(t, uint16(0x34), optical.PowerFeedVoltage)
+
+ assert.Equal(t, uint8(3), optical.ReceivedOpticalPowerType)
+ assert.Equal(t, uint16(0x67), optical.ReceivedOpticalPower)
+
+ assert.Equal(t, uint8(5), optical.MeanOpticalLaunchType)
+ assert.Equal(t, uint16(0x91), optical.MeanOpticalLaunch)
+
+ assert.Equal(t, uint8(9), optical.LaserBiasCurrentType)
+ assert.Equal(t, uint16(0x34), optical.LaserBiasCurrent)
+
+ assert.Equal(t, uint8(12), optical.TemperatureType)
+ assert.Equal(t, uint16(0x67), optical.Temperature)
+
+ assert.Equal(t, uint16(0x8901), optical.GeneralPurposeBuffer)
+
+ // Verify string output for message
+ packetString := packet.String()
+ assert.NotZero(t, len(packetString))
+}
+
+func TestExtendedGenericTestResultSerialize(t *testing.T) {
+ payload := "12345678901234567890"
+ resultLen := len(payload) / 2
+ goodMessage := "00001b0b01000000" + fmt.Sprintf("%04x", resultLen) + payload
+
+ omciLayer := &OMCI{
+ // TransactionID: 0x0c, // Optional for notifications since TID always 0x0000
+ MessageType: TestResultType,
+ 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.
+ }
+ data, derr := stringToPacket(payload)
+ assert.NoError(t, derr)
+
+ request := &TestResultNotification{
+ MeBasePacket: MeBasePacket{
+ EntityClass: me.OnuGClassID,
+ EntityInstance: uint16(0),
+ Extended: true,
+ },
+ Payload: data,
+ }
+ // 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 TestExtendedOpticalLineSupervisionTestResultSerialize(t *testing.T) {
+ // ANI-G ME for this test with just made up data
+ payload := "010034" + "030067" + "050091" + "090034" + "0c0067" + "8901"
+ resultLen := len(payload) / 2
+ goodMessage := "00001b0b01078001" + fmt.Sprintf("%04x", resultLen) + payload
+
+ omciLayer := &OMCI{
+ // TransactionID: 0x0c, // Optional for notifications since TID always 0x0000
+ MessageType: TestResultType,
+ 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 := &OpticalLineSupervisionTestResult{
+ MeBasePacket: MeBasePacket{
+ EntityClass: me.AniGClassID,
+ EntityInstance: uint16(0x8001),
+ Extended: true,
+ },
+ PowerFeedVoltageType: uint8(1),
+ PowerFeedVoltage: uint16(0x34),
+ ReceivedOpticalPowerType: uint8(3),
+ ReceivedOpticalPower: uint16(0x67),
+ MeanOpticalLaunchType: uint8(5),
+ MeanOpticalLaunch: uint16(0x91),
+ LaserBiasCurrentType: uint8(9),
+ LaserBiasCurrent: uint16(0x34),
+ TemperatureType: uint8(12),
+ Temperature: uint16(0x67),
+ GeneralPurposeBuffer: uint16(0x8901),
+ }
+ // 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)
+}