VOL-4337: Code upgrade for 3/2020 G.988 support and remaining Extended Message Set support
Change-Id: I6c5e1a167216ad9b51e9da89460e9909465ae1bc
diff --git a/messagetypes_test.go b/messagetypes_test.go
index 69f8abe..a22e7ef 100644
--- a/messagetypes_test.go
+++ b/messagetypes_test.go
@@ -17,9 +17,6 @@
package omci_test
import (
- "encoding/base64"
- "encoding/binary"
- "fmt"
"github.com/google/gopacket"
. "github.com/opencord/omci-lib-go"
me "github.com/opencord/omci-lib-go/generated"
@@ -100,11 +97,6 @@
TestResultType,
}
-var allExtendedMessageTypes = [...]MessageType{
- GetRequestType,
- GetResponseType,
-}
-
var allResults = [...]me.Results{
me.Success,
me.ProcessingError,
@@ -260,483 +252,8 @@
assert.Equal(t, strings.ToLower(goodMessage), reconstituted)
}
-func TestCreateRequestDecode(t *testing.T) {
- goodMessage := "000C440A010C01000400800003010000" +
- "00000000000000000000000000000000" +
- "000000000000000000000028"
- 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, omciMsg.TransactionID, uint16(0xc))
- assert.Equal(t, omciMsg.MessageType, CreateRequestType)
- assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- assert.Equal(t, omciMsg.Length, uint16(40))
-
- msgLayer := packet.Layer(LayerTypeCreateRequest)
- assert.NotNil(t, msgLayer)
-
- request, ok2 := msgLayer.(*CreateRequest)
- assert.True(t, ok2)
- assert.Equal(t, request.EntityClass, me.GemPortNetworkCtpClassID)
- assert.Equal(t, request.EntityInstance, uint16(0x100))
-
- attributes := request.Attributes
- assert.NotNil(t, attributes)
-
- // As this is a create request, gather up all set-by-create attributes
- // make sure we got them all, and nothing else
- meDefinition, omciErr := me.LoadManagedEntityDefinition(request.EntityClass)
- assert.NotNil(t, omciErr)
- assert.Equal(t, omciErr.StatusCode(), me.Success)
-
- attrDefs := meDefinition.GetAttributeDefinitions()
-
- sbcMask := getSbcMask(meDefinition)
- for index := uint(1); index < uint(len(attrDefs)); index++ {
- attrName := attrDefs[index].GetName()
-
- if sbcMask&uint16(1<<(uint)(16-index)) != 0 {
- _, ok3 := attributes[attrName]
- assert.True(t, ok3)
- } else {
- _, ok3 := attributes[attrName]
- assert.False(t, ok3)
- }
- //fmt.Printf("Name: %v, Value: %v\n", attrName, attributes[attrName])
- }
- // Test serialization back to former string
- var options gopacket.SerializeOptions
- options.FixLengths = true
-
- buffer := gopacket.NewSerializeBuffer()
- err = gopacket.SerializeLayers(buffer, options, omciMsg, request)
- assert.NoError(t, err)
-
- outgoingPacket := buffer.Bytes()
- reconstituted := packetToString(outgoingPacket)
- assert.Equal(t, strings.ToLower(goodMessage), reconstituted)
-
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-func TestCreateRequestSerialize(t *testing.T) {
- goodMessage := "000C440A010C0100040080000301000000000000000000000000000000000000000000000000000000000028"
-
- omciLayer := &OMCI{
- TransactionID: 0x0c,
- MessageType: CreateRequestType,
- // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // Length: 0x28, // Optional, defaults to 40 octets
- }
- request := &CreateRequest{
- MeBasePacket: MeBasePacket{
- EntityClass: me.GemPortNetworkCtpClassID,
- EntityInstance: uint16(0x100),
- },
- Attributes: me.AttributeValueMap{
- "PortId": 0x400,
- "TContPointer": 0x8000,
- "Direction": 3,
- "TrafficManagementPointerForUpstream": 0x100,
- "TrafficDescriptorProfilePointerForUpstream": 0,
- "PriorityQueuePointerForDownStream": 0,
- "TrafficDescriptorProfilePointerForDownstream": 0,
- "EncryptionKeyRing": 0,
- },
- }
- // 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 TestCreateResponseDecode(t *testing.T) {
- goodMessage := "0157240a01100001000000000000000000000000000000000000000000000000000000000000000000000028a9ccbeb9"
- 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, omciMsg.TransactionID, uint16(0x0157))
- assert.Equal(t, omciMsg.MessageType, CreateResponseType)
- assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- assert.Equal(t, omciMsg.Length, uint16(40))
-
- msgLayer := packet.Layer(LayerTypeCreateResponse)
- assert.NotNil(t, msgLayer)
-
- response, ok2 := msgLayer.(*CreateResponse)
- assert.True(t, ok2)
- assert.NotNil(t, response)
-
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-func TestCreateResponseSerialize(t *testing.T) {
- goodMessage := "0157240a01100001000000000000000000000000000000000000000000000000000000000000000000000028"
-
- omciLayer := &OMCI{
- TransactionID: 0x0157,
- MessageType: CreateResponseType,
- // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // Length: 0x28, // Optional, defaults to 40 octets
- }
- request := &CreateResponse{
- MeBasePacket: MeBasePacket{
- EntityClass: me.GalEthernetProfileClassID,
- EntityInstance: uint16(1),
- },
- Result: me.Success,
- AttributeExecutionMask: uint16(0),
- }
- // 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 TestDeleteRequestDecode(t *testing.T) {
- goodMessage := "0211460a00ab0202000000000000000000000000000000000000000000000000000000000000000000000028"
- 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, omciMsg.TransactionID, uint16(0x0211))
- assert.Equal(t, omciMsg.MessageType, DeleteRequestType)
- assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- assert.Equal(t, omciMsg.Length, uint16(40))
-
- msgLayer := packet.Layer(LayerTypeDeleteRequest)
-
- assert.NotNil(t, msgLayer)
-
- request, ok2 := msgLayer.(*DeleteRequest)
- assert.True(t, ok2)
- assert.NotNil(t, request)
-
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-func TestDeleteRequestSerialize(t *testing.T) {
- goodMessage := "0211460a00ab0202000000000000000000000000000000000000000000000000000000000000000000000028"
-
- omciLayer := &OMCI{
- TransactionID: 0x0211,
- MessageType: DeleteRequestType,
- // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // Length: 0x28, // Optional, defaults to 40 octets
- }
- request := &DeleteRequest{
- MeBasePacket: MeBasePacket{
- EntityClass: me.ExtendedVlanTaggingOperationConfigurationDataClassID,
- EntityInstance: uint16(0x202),
- },
- }
- // 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 TestDeleteResponseDecode(t *testing.T) {
- goodMessage := "0211260a00ab0202000000000000000000000000000000000000000000000000000000000000000000000028013437fb"
- 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, omciMsg.TransactionID, uint16(0x0211))
- assert.Equal(t, omciMsg.MessageType, DeleteResponseType)
- assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- assert.Equal(t, omciMsg.Length, uint16(40))
-
- msgLayer := packet.Layer(LayerTypeDeleteResponse)
-
- assert.NotNil(t, msgLayer)
-
- response, ok2 := msgLayer.(*DeleteResponse)
- assert.True(t, ok2)
- assert.NotNil(t, response)
-
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-func TestDeleteResponseSerialize(t *testing.T) {
- goodMessage := "0211260a00ab0202000000000000000000000000000000000000000000000000000000000000000000000028"
-
- omciLayer := &OMCI{
- TransactionID: 0x0211,
- MessageType: DeleteResponseType,
- // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // Length: 0x28, // Optional, defaults to 40 octets
- }
- request := &DeleteResponse{
- MeBasePacket: MeBasePacket{
- EntityClass: me.ExtendedVlanTaggingOperationConfigurationDataClassID,
- EntityInstance: uint16(0x202),
- },
- 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 TestSetRequestDecode(t *testing.T) {
- goodMessage := "0107480a01000000020000000000000000000000000000000000000000000000000000000000000000000028"
- 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, omciMsg.TransactionID, uint16(0x0107))
- assert.Equal(t, omciMsg.MessageType, SetRequestType)
- assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- assert.Equal(t, omciMsg.Length, uint16(40))
-
- msgLayer := packet.Layer(LayerTypeSetRequest)
- assert.NotNil(t, msgLayer)
-
- request, ok2 := msgLayer.(*SetRequest)
- assert.True(t, ok2)
- assert.NotNil(t, request)
-
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-func TestSetRequestSerialize(t *testing.T) {
- goodMessage := "0107480a01000000020000000000000000000000000000000000000000000000000000000000000000000028"
-
- omciLayer := &OMCI{
- TransactionID: 0x0107,
- MessageType: SetRequestType,
- // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // Length: 0x28, // Optional, defaults to 40 octets
- }
- request := &SetRequest{
- MeBasePacket: MeBasePacket{
- EntityClass: me.OnuGClassID,
- EntityInstance: uint16(0),
- },
- AttributeMask: uint16(0x200),
- Attributes: me.AttributeValueMap{"AdministrativeState": byte(0)},
- }
- // 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 TestSetResponseDecode(t *testing.T) {
- goodMessage := "0107280a01000000000000000000000000000000000000000000000000000000000000000000000000000028"
- 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, omciMsg.TransactionID, uint16(0x0107))
- assert.Equal(t, omciMsg.MessageType, SetResponseType)
- assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- assert.Equal(t, omciMsg.Length, uint16(40))
-
- msgLayer := packet.Layer(LayerTypeSetResponse)
- assert.NotNil(t, msgLayer)
-
- response, ok2 := msgLayer.(*SetResponse)
- assert.True(t, ok2)
- assert.NotNil(t, response)
-
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-func TestSetResponseSerialize(t *testing.T) {
- goodMessage := "0107280a01000000000000000000000000000000000000000000000000000000000000000000000000000028"
-
- omciLayer := &OMCI{
- TransactionID: 0x0107,
- MessageType: SetResponseType,
- // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // Length: 0x28, // Optional, defaults to 40 octets
- }
- request := &SetResponse{
- MeBasePacket: MeBasePacket{
- EntityClass: me.OnuGClassID,
- EntityInstance: uint16(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 TestSetResponseTableFailedAttributesDecode(t *testing.T) {
- // This is a SET Response with failed and unsupported attributes
- // TODO:Implement
-}
-
-func TestSetResponseTableFailedAttributesSerialize(t *testing.T) {
- // This is a SET Response with failed and unsupported attributes
- // TODO:Implement
-}
-
-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, omciMsg.TransactionID, uint16(0x035e))
- assert.Equal(t, omciMsg.MessageType, GetRequestType)
- assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- assert.Equal(t, omciMsg.Length, uint16(40))
-
- msgLayer := packet.Layer(LayerTypeGetRequest)
- assert.NotNil(t, msgLayer)
-
- request, ok2 := msgLayer.(*GetRequest)
- assert.True(t, ok2)
- assert.NotNil(t, request)
-
- // 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 TestGetResponseDecode(t *testing.T) {
- goodMessage := "035e290a01070000000044dbcb05f10000000000000000000000000000000000000000000000000000000028"
+func TestGetSoftwareImageResponseDecode(t *testing.T) {
+ goodMessage := "035e290a00070000000400000102030405060708090a0b0c0d0e0f0000000000000000000000000000000028"
data, err := stringToPacket(goodMessage)
assert.NoError(t, err)
@@ -760,2233 +277,29 @@
assert.True(t, ok2)
assert.NotNil(t, response)
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))
+ assert.Equal(t, response.AttributeMask, uint16(0x0400))
+ assert.Equal(t, response.Attributes["ImageHash"], toOctets("AAECAwQFBgcICQoLDA0ODw==")) // 0->f octets)
// Verify string output for message
packetString := packet.String()
assert.NotZero(t, len(packetString))
}
-func TestGetResponseSerialize(t *testing.T) {
- goodMessage := "035e290a01070000000044dbcb05f10000000000000000000000000000000000000000000000000000000028"
-
+func TestGetSoftwareImageResponseSerialize(t *testing.T) {
+ goodMessage := "035e290a00070000000400000102030405060708090a0b0c0d0e0f0000000000000000000000000000000028"
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,
+ EntityClass: me.SoftwareImageClassID,
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)
-}
-
-///////////////////////////////////////////////////////////////////////
-// 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, omciLayer.TransactionID, omciMsg2.TransactionID)
- assert.Equal(t, omciLayer.MessageType, GetResponseType)
- assert.Equal(t, omciLayer.DeviceIdentifier, BaselineIdent)
- assert.Equal(t, omciLayer.Length, uint16(40))
-
- msgLayer2 := packet.Layer(LayerTypeGetResponse)
- assert.NotNil(t, msgLayer2)
-
- response2, ok2 := msgLayer2.(*GetResponse)
- assert.True(t, ok2)
- 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 TestGetAllAlarmsRequestDecode(t *testing.T) {
- goodMessage := "04454b0a00020000000000000000000000000000000000000000000000000000000000000000000000000028"
- 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, omciMsg.TransactionID, uint16(0x0445))
- assert.Equal(t, omciMsg.MessageType, GetAllAlarmsRequestType)
- assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- assert.Equal(t, omciMsg.Length, uint16(40))
-
- msgLayer := packet.Layer(LayerTypeGetAllAlarmsRequest)
- assert.NotNil(t, msgLayer)
-
- request, ok2 := msgLayer.(*GetAllAlarmsRequest)
- assert.True(t, ok2)
- assert.NotNil(t, request)
- assert.Equal(t, request.AlarmRetrievalMode, byte(0))
-
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-func TestGetAllAlarmsRequestSerialize(t *testing.T) {
- goodMessage := "04454b0a00020000010000000000000000000000000000000000000000000000000000000000000000000028"
-
- omciLayer := &OMCI{
- TransactionID: 0x0445,
- MessageType: GetAllAlarmsRequestType,
- // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // Length: 0x28, // Optional, defaults to 40 octets
- }
- request := &GetAllAlarmsRequest{
- MeBasePacket: MeBasePacket{
- EntityClass: me.OnuDataClassID,
- EntityInstance: uint16(0),
- },
- AlarmRetrievalMode: 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.NoError(t, err)
-
- outgoingPacket := buffer.Bytes()
- reconstituted := packetToString(outgoingPacket)
- assert.Equal(t, strings.ToLower(goodMessage), reconstituted)
-}
-
-func TestGetAllAlarmsResponseDecode(t *testing.T) {
- goodMessage := "04452b0a00020000000300000000000000000000000000000000000000000000000000000000000000000028"
- 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, omciMsg.TransactionID, uint16(0x0445))
- assert.Equal(t, omciMsg.MessageType, GetAllAlarmsResponseType)
- assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- assert.Equal(t, omciMsg.Length, uint16(40))
-
- msgLayer := packet.Layer(LayerTypeGetAllAlarmsResponse)
- assert.NotNil(t, msgLayer)
-
- response, ok2 := msgLayer.(*GetAllAlarmsResponse)
- assert.True(t, ok2)
- assert.NotNil(t, response)
- assert.Equal(t, response.NumberOfCommands, uint16(3))
-
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-func TestGetAllAlarmsResponseSerialize(t *testing.T) {
- goodMessage := "04452b0a00020000000300000000000000000000000000000000000000000000000000000000000000000028"
-
- omciLayer := &OMCI{
- TransactionID: 0x0445,
- MessageType: GetAllAlarmsResponseType,
- // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // Length: 0x28, // Optional, defaults to 40 octets
- }
- request := &GetAllAlarmsResponse{
- MeBasePacket: MeBasePacket{
- EntityClass: me.OnuDataClassID,
- EntityInstance: uint16(0),
- },
- NumberOfCommands: uint16(3),
- }
- // 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 TestGetAllAlarmsNextRequestDecode(t *testing.T) {
- goodMessage := "02344c0a00020000000000000000000000000000000000000000000000000000000000000000000000000028"
-
- 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, omciMsg.TransactionID, uint16(0x0234))
- assert.Equal(t, omciMsg.MessageType, GetAllAlarmsNextRequestType)
- assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- assert.Equal(t, omciMsg.Length, uint16(40))
-
- msgLayer := packet.Layer(LayerTypeGetAllAlarmsNextRequest)
- assert.NotNil(t, msgLayer)
-
- request, ok2 := msgLayer.(*GetAllAlarmsNextRequest)
- assert.True(t, ok2)
- assert.NotNil(t, request)
-
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-func TestGetAllAlarmsNextRequestSerialize(t *testing.T) {
- goodMessage := "02344c0a00020000000000000000000000000000000000000000000000000000000000000000000000000028"
-
- omciLayer := &OMCI{
- TransactionID: 0x0234,
- MessageType: GetAllAlarmsNextRequestType,
- // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // Length: 0x28, // Optional, defaults to 40 octets
- }
- request := &GetAllAlarmsNextRequest{
- MeBasePacket: MeBasePacket{
- EntityClass: me.OnuDataClassID,
- EntityInstance: uint16(0),
- },
- CommandSequenceNumber: uint16(0),
- }
- // 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 TestGetAllAlarmsNextResponseDecode(t *testing.T) {
- goodMessage := "02342c0a00020000000b01028000000000000000000000000000000000000000000000000000000000000028f040fc87"
- 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, omciMsg.TransactionID, uint16(0x0234))
- assert.Equal(t, omciMsg.MessageType, GetAllAlarmsNextResponseType)
- assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- assert.Equal(t, omciMsg.Length, uint16(40))
-
- msgLayer := packet.Layer(LayerTypeGetAllAlarmsNextResponse)
- assert.NotNil(t, msgLayer)
-
- response, ok2 := msgLayer.(*GetAllAlarmsNextResponse)
- assert.True(t, ok2)
- assert.NotNil(t, response)
-
- var alarms [224 / 8]byte
- alarms[0] = 0x80
- assert.Equal(t, response.AlarmEntityClass, me.PhysicalPathTerminationPointEthernetUniClassID)
- assert.Equal(t, response.AlarmEntityInstance, uint16(0x102))
- assert.Equal(t, response.AlarmBitMap, alarms)
-
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-func TestGetAllAlarmsNextResponseSerialize(t *testing.T) {
- goodMessage := "02342c0a00020000000b01028000000000000000000000000000000000000000000000000000000000000028"
-
- omciLayer := &OMCI{
- TransactionID: 0x0234,
- MessageType: GetAllAlarmsNextResponseType,
- // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // Length: 0x28, // Optional, defaults to 40 octets
- }
- var alarms [224 / 8]byte
- alarms[0] = 0x80
-
- request := &GetAllAlarmsNextResponse{
- MeBasePacket: MeBasePacket{
- EntityClass: me.OnuDataClassID,
- EntityInstance: uint16(0),
- },
- AlarmEntityClass: me.PhysicalPathTerminationPointEthernetUniClassID,
- AlarmEntityInstance: uint16(0x102),
- AlarmBitMap: alarms,
- }
- // 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 TestGetAllAlarmsNextResponseBadCommandNumberDecode(t *testing.T) {
- // Test of a GetNext Response that results when an invalid command number
- // is requested. In the case where the ONU receives a get all alarms next
- // request message in which the command sequence number is out of range,
- // the ONU should respond with a message in which bytes 9 to 40 are all
- // set to 0. This corresponds to a response with entity class 0, entity
- // instance 0, and bit map all 0s.
- //TODO: Implement
-}
-
-func TestGetAllAlarmsNextResponseBadCommandNumberSerialize(t *testing.T) {
- // Test of a GetNext Response that results when an invalid command number
- // is requested.
- //TODO: Implement
-}
-
-func TestMibUploadRequestDecode(t *testing.T) {
- goodMessage := "03604d0a00020000000000000000000000000000000000000000000000000000000000000000000000000028"
- 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, omciMsg.TransactionID, uint16(0x0360))
- assert.Equal(t, omciMsg.MessageType, MibUploadRequestType)
- assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- assert.Equal(t, omciMsg.Length, uint16(40))
- msgLayer := packet.Layer(LayerTypeMibUploadRequest)
-
- assert.NotNil(t, msgLayer)
-
- request, ok2 := msgLayer.(*MibUploadRequest)
- assert.True(t, ok2)
- assert.NotNil(t, request)
-
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-func TestMibUploadRequestSerialize(t *testing.T) {
- goodMessage := "03604d0a00020000000000000000000000000000000000000000000000000000000000000000000000000028"
-
- omciLayer := &OMCI{
- TransactionID: 0x0360,
- MessageType: MibUploadRequestType,
- // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // Length: 0x28, // Optional, defaults to 40 octets
- }
- var alarms [224 / 8]byte
- alarms[0] = 0x80
-
- request := &MibUploadRequest{
- MeBasePacket: MeBasePacket{
- EntityClass: me.OnuDataClassID,
- EntityInstance: uint16(0),
- },
- }
- // 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 TestMibUploadResponse(t *testing.T) {
- goodMessage := "03602d0a00020000011200000000000000000000000000000000000000000000000000000000000000000028"
- 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, omciMsg.TransactionID, uint16(0x0360))
- assert.Equal(t, omciMsg.MessageType, MibUploadResponseType)
- assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- assert.Equal(t, omciMsg.Length, uint16(40))
-
- msgLayer := packet.Layer(LayerTypeMibUploadResponse)
- assert.NotNil(t, msgLayer)
-
- response, ok2 := msgLayer.(*MibUploadResponse)
- assert.True(t, ok2)
- assert.NotNil(t, response)
- assert.Equal(t, response.NumberOfCommands, uint16(0x112))
-}
-
-func TestMibUploadResponseSerialize(t *testing.T) {
- goodMessage := "03602d0a00020000011200000000000000000000000000000000000000000000000000000000000000000028"
-
- omciLayer := &OMCI{
- TransactionID: 0x0360,
- MessageType: MibUploadResponseType,
- // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // Length: 0x28, // Optional, defaults to 40 octets
- }
- var alarms [224 / 8]byte
- alarms[0] = 0x80
-
- request := &MibUploadResponse{
- MeBasePacket: MeBasePacket{
- EntityClass: me.OnuDataClassID,
- EntityInstance: uint16(0),
- },
- NumberOfCommands: uint16(0x112),
- }
- // 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 TestMibUploadNextRequestDecode(t *testing.T) {
- goodMessage := "02864e0a00020000003a00000000000000000000000000000000000000000000000000000000000000000028"
- 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, omciMsg.TransactionID, uint16(0x0286))
- assert.Equal(t, omciMsg.MessageType, MibUploadNextRequestType)
- assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- assert.Equal(t, omciMsg.Length, uint16(40))
-
- msgLayer := packet.Layer(LayerTypeMibUploadNextRequest)
- assert.NotNil(t, msgLayer)
-
- request, ok2 := msgLayer.(*MibUploadNextRequest)
- assert.True(t, ok2)
- assert.NotNil(t, request)
- assert.Equal(t, request.CommandSequenceNumber, uint16(0x3a))
-
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-func TestMibUploadNextRequestSerialize(t *testing.T) {
- goodMessage := "02864e0a00020000003a00000000000000000000000000000000000000000000000000000000000000000028"
-
- omciLayer := &OMCI{
- TransactionID: 0x0286,
- MessageType: MibUploadNextRequestType,
- // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // Length: 0x28, // Optional, defaults to 40 octets
- }
- request := &MibUploadNextRequest{
- MeBasePacket: MeBasePacket{
- EntityClass: me.OnuDataClassID,
- EntityInstance: uint16(0),
- },
- CommandSequenceNumber: uint16(0x3a),
- }
- // 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 TestMibUploadNextResponseDecode(t *testing.T) {
- goodMessage := "02862e0a0002000001150000fff0000000000000000000010100000000010000000000000000000000000028"
- 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, omciMsg.TransactionID, uint16(0x0286))
- assert.Equal(t, omciMsg.MessageType, MibUploadNextResponseType)
- assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- assert.Equal(t, omciMsg.Length, uint16(40))
-
- msgLayer := packet.Layer(LayerTypeMibUploadNextResponse)
- assert.NotNil(t, msgLayer)
-
- response, ok2 := msgLayer.(*MibUploadNextResponse)
- assert.True(t, ok2)
- assert.NotNil(t, response)
- assert.Equal(t, response.ReportedME.GetClassID(), me.PriorityQueueClassID)
- assert.Equal(t, response.ReportedME.GetEntityID(), uint16(0))
-
- attributes := me.AttributeValueMap{
- "QueueConfigurationOption": byte(0),
- "MaximumQueueSize": uint16(0),
- "AllocatedQueueSize": uint16(0),
- "DiscardBlockCounterResetInterval": uint16(0),
- "ThresholdValueForDiscardedBlocksDueToBufferOverflow": uint16(0),
- "RelatedPort": uint32(16842752),
- "TrafficSchedulerPointer": uint16(0),
- "Weight": byte(1),
- "BackPressureOperation": uint16(0),
- "BackPressureTime": uint32(0),
- "BackPressureOccurQueueThreshold": uint16(0),
- "BackPressureClearQueueThreshold": uint16(0),
- }
- for name, value := range attributes {
- pktValue, err := response.ReportedME.GetAttribute(name)
- assert.Nil(t, err)
- assert.Equal(t, pktValue, value)
- }
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-func TestMibUploadNextResponseSerialize(t *testing.T) {
- goodMessage := "02862e0a0002000001150000fff0000000000000000000010100000000010000000000000000000000000028"
-
- omciLayer := &OMCI{
- TransactionID: 0x0286,
- MessageType: MibUploadNextResponseType,
- // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // Length: 0x28, // Optional, defaults to 40 octets
- }
- paramData := me.ParamData{
- EntityID: uint16(0),
- Attributes: me.AttributeValueMap{
- "QueueConfigurationOption": byte(0),
- "MaximumQueueSize": uint16(0),
- "AllocatedQueueSize": uint16(0),
- "DiscardBlockCounterResetInterval": uint16(0),
- "ThresholdValueForDiscardedBlocksDueToBufferOverflow": uint16(0),
- "RelatedPort": uint32(16842752),
- "TrafficSchedulerPointer": uint16(0),
- "Weight": byte(1),
- "BackPressureOperation": uint16(0),
- "BackPressureTime": uint32(0),
- "BackPressureOccurQueueThreshold": uint16(0),
- "BackPressureClearQueueThreshold": uint16(0),
- },
- }
- reportedME, err := me.NewPriorityQueue(paramData)
- assert.NotNil(t, err)
- assert.Equal(t, err.StatusCode(), me.Success)
-
- request := &MibUploadNextResponse{
- MeBasePacket: MeBasePacket{
- EntityClass: me.OnuDataClassID,
- EntityInstance: uint16(0),
- },
- ReportedME: *reportedME,
- }
- // Test serialization back to former string
- var options gopacket.SerializeOptions
- options.FixLengths = true
-
- buffer := gopacket.NewSerializeBuffer()
- omciErr := gopacket.SerializeLayers(buffer, options, omciLayer, request)
- assert.NoError(t, omciErr)
-
- outgoingPacket := buffer.Bytes()
- reconstituted := packetToString(outgoingPacket)
- assert.Equal(t, strings.ToLower(goodMessage), reconstituted)
-}
-
-func TestMibUploadNextResponseBadCommandNumberDecode(t *testing.T) {
- // Test of a MIB Upload next Response that results when an invalid command number.
- // Note that if all attributes of a managed entity do not fit within one MIB
- // upload next response message, the attributes will be split over several
- // messages. The OLT can use the information in the attribute mask to determine
- // which attribute values are reported in which MIB upload next response message.
- //TODO: Implement
-}
-
-func TestMibUploadNextResponseBadCommandNumberSerialize(t *testing.T) {
- // Test of a MIB Upload next Response that results when an invalid command number
- // is requested.
- //TODO: Implement
-}
-
-// TODO: Create request/response tests for all of the following types
-//Test,
-// 1 2 3 4
-// 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4
-// 0004530a00070001ff000f424001000100000000000000000000000000000000000000000000000000000028
-// 0004530a
-// 00070001 - ONU-G instance 0001
-// ff - window size - 1
-// 000f4240 - image size
-// 01
-// 000100000000000000000000000000000000000000000000000000000028
-func TestStartSoftwareDownloadRequestDecode(t *testing.T) {
- goodMessage := "0004530a00070001ff000f424001000100000000000000000000000000000000000000000000000000000028"
- 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(0x0004), omciMsg.TransactionID)
- assert.Equal(t, StartSoftwareDownloadRequestType, omciMsg.MessageType)
- assert.True(t, omciMsg.ResponseExpected)
- assert.Equal(t, BaselineIdent, omciMsg.DeviceIdentifier)
- assert.Equal(t, uint16(40), omciMsg.Length)
-
- msgLayer := packet.Layer(LayerTypeStartSoftwareDownloadRequest)
- assert.NotNil(t, msgLayer)
-
- request, ok2 := msgLayer.(*StartSoftwareDownloadRequest)
- assert.True(t, ok2)
- assert.NotNil(t, request)
- assert.Equal(t, uint8(0xff), request.WindowSize)
- assert.Equal(t, uint32(0x000f4240), request.ImageSize)
-
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-func TestStartSoftwareDownloadRequestSerialize(t *testing.T) {
- //// TODO: Need to complete implementation & debug this
- //goodMessage := "0000530a0007000113000f424001000100000000000000000000000000000000000000000000000000000028"
- //
- //omciLayer := &OMCI{
- // TransactionID: 0x01,
- // MessageType: StartSoftwareDownloadRequestType,
- // // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // // Length: 0x28, // Optional, defaults to 40 octets
- //}
- //request := &StartSoftwareDownloadRequest{
- // MeBasePacket: MeBasePacket{
- // EntityClass: OnuDataClassID,
- // // Default Instance ID is 0
- // },
- //}
- //// 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 TestStartSoftwareDownloadResponseDecode(t *testing.T) {
- // TODO: Need to complete implementation & debug this
- //goodMessage := ""
- //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, omciMsg.TransactionID, uint16(0x0))
- //assert.Equal(t, omciMsg.MessageType, StartSoftwareDownloadResponseType)
- //assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- //assert.Equal(t, omciMsg.Length, uint16(40))
- //
- //msgLayer := packet.Layer(LayerTypeStartSoftwareDownloadResponse)
- //
- //assert.NotNil(t, msgLayer)
- //
- //response, ok2 := msgLayer.(*StartSoftwareDownloadResponse)
- //assert.True(t, ok2)
- //assert.NotNil(t, response)
- //
- //// Verify string output for message
- //packetString := packet.String()
- //assert.NotZero(t, len(packetString))
-}
-
-func TestStartSoftwareDownloadResponseSerialize(t *testing.T) {
- // TODO: Need to complete implementation & debug this
- //goodMessage := ""
- //
- //omciLayer := &OMCI{
- // TransactionID: 0x01,
- // MessageType: StartSoftwareDownloadResponseType,
- // // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // // Length: 0x28, // Optional, defaults to 40 octets
- //}
- //request := &StartSoftwareDownloadResponse{
- // MeBasePacket: MeBasePacket{
- // EntityClass: OnuDataClassID,
- // // Default Instance ID is 0
- // },
- //}
- //// 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)
-}
-
-// 1 2 3 4
-// 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4
-// 0008140a00070001 - Download section, AR=0
-// cc - Section 0xcc
-// 01020304050607080910111213141516171819202122232425262728293031
-// 00000028
-
-func TestDownloadSectionRequestDecodeNoResponseExpected(t *testing.T) {
- goodMessage := "0008140a00070001cc0102030405060708091011121314151617181920212223242526272829303100000028"
- 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(0x0008), omciMsg.TransactionID)
- assert.Equal(t, DownloadSectionRequestType, omciMsg.MessageType)
- assert.False(t, omciMsg.ResponseExpected)
- assert.Equal(t, BaselineIdent, omciMsg.DeviceIdentifier)
- assert.Equal(t, uint16(40), omciMsg.Length)
-
- msgLayer := packet.Layer(LayerTypeDownloadSectionRequest)
- assert.NotNil(t, msgLayer)
-
- request, ok2 := msgLayer.(*DownloadSectionRequest)
- assert.True(t, ok2)
- assert.NotNil(t, request)
- assert.Equal(t, uint8(0xcc), request.SectionNumber)
- assert.Equal(t, MaxDownloadSectionLength, len(request.SectionData))
-
- sectionData, genErr := stringToPacket("01020304050607080910111213141516171819202122232425262728293031")
- assert.Nil(t, genErr)
- assert.NotNil(t, sectionData)
- assert.Equal(t, MaxDownloadSectionLength, len(sectionData))
- assert.Equal(t, sectionData, request.SectionData[:])
-
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-func TestDownloadSectionRequestDecodeResponseExpected(t *testing.T) {
- goodMessage := "0008540a00070001cc0102030405060708091011121314151617181920212223242526272829303100000028"
- 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(0x0008), omciMsg.TransactionID)
- assert.Equal(t, DownloadSectionRequestWithResponseType, omciMsg.MessageType)
- assert.True(t, omciMsg.ResponseExpected)
- assert.Equal(t, BaselineIdent, omciMsg.DeviceIdentifier)
- assert.Equal(t, uint16(40), omciMsg.Length)
-
- msgLayer := packet.Layer(LayerTypeDownloadSectionRequest)
- assert.NotNil(t, msgLayer)
-
- request, ok2 := msgLayer.(*DownloadSectionRequest)
- assert.True(t, ok2)
- assert.NotNil(t, request)
- assert.Equal(t, uint8(0xcc), request.SectionNumber)
- assert.Equal(t, 31, len(request.SectionData))
-
- sectionData, genErr := stringToPacket("01020304050607080910111213141516171819202122232425262728293031")
- assert.Nil(t, genErr)
- assert.NotNil(t, sectionData)
- assert.Equal(t, MaxDownloadSectionLength, len(sectionData))
- assert.Equal(t, sectionData, request.SectionData[:])
-
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-func TestDownloadSectionRequestSerializeNoResponseExpected(t *testing.T) {
- goodMessage := "0123140a00070000cc0102030405060708091011121314151617181920212223242526272829303100000028"
-
- omciLayer := &OMCI{
- TransactionID: 0x0123,
- MessageType: DownloadSectionRequestType,
- // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // Length: 0x28, // Optional, defaults to 40 octets
- }
- sectionData, genErr := stringToPacket("01020304050607080910111213141516171819202122232425262728293031")
- assert.Nil(t, genErr)
- assert.NotNil(t, sectionData)
- assert.Equal(t, MaxDownloadSectionLength, len(sectionData))
-
- request := &DownloadSectionRequest{
- MeBasePacket: MeBasePacket{
- EntityClass: me.SoftwareImageClassID,
- // Default Instance ID is 0
- },
- SectionNumber: 0xcc,
- SectionData: sectionData,
- }
- // 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 TestDownloadSectionRequestSerializeNoResponsePartialDataExpected(t *testing.T) {
- // If a small buffer is provided, serialize will now zero extend the baseline format
- goodMessage := "0123140a00070000cc0102030405060708091011121314151617181920212223242526272829000000000028"
-
- omciLayer := &OMCI{
- TransactionID: 0x0123,
- MessageType: DownloadSectionRequestType,
- // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // Length: 0x28, // Optional, defaults to 40 octets
- }
- sectionData, genErr := stringToPacket("0102030405060708091011121314151617181920212223242526272829")
- assert.Nil(t, genErr)
- assert.NotNil(t, sectionData)
- assert.Equal(t, MaxDownloadSectionLength-2, len(sectionData)) // Partial data buffer
-
- request := &DownloadSectionRequest{
- MeBasePacket: MeBasePacket{
- EntityClass: me.SoftwareImageClassID,
- // Default Instance ID is 0
- },
- SectionNumber: 0xcc,
- SectionData: sectionData,
- }
- // 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 TestDownloadSectionRequestSerializeResponseExpectedMethod1(t *testing.T) {
- goodMessage := "2468540a00070000cc0102030405060708091011121314151617181920212223242526272829303100000028"
-
- omciLayer := &OMCI{
- TransactionID: 0x2468,
- MessageType: DownloadSectionRequestType, // or DownloadSectionRequestWithResponseType
- ResponseExpected: true,
- // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // Length: 0x28, // Optional, defaults to 40 octets
- }
- sectionData, genErr := stringToPacket("01020304050607080910111213141516171819202122232425262728293031")
- assert.Nil(t, genErr)
- assert.NotNil(t, sectionData)
- assert.Equal(t, MaxDownloadSectionLength, len(sectionData))
-
- request := &DownloadSectionRequest{
- MeBasePacket: MeBasePacket{
- EntityClass: me.SoftwareImageClassID,
- // Default Instance ID is 0
- },
- SectionNumber: 0xcc,
- SectionData: sectionData,
- }
- // 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 TestDownloadSectionRequestSerializeResponseExpectedMethod2(t *testing.T) {
- goodMessage := "2468540a00070001cc0102030405060708091011121314151617181920212223242526272829303100000028"
-
- // In this case, just use the request type with AR response requested already encoded
- omciLayer := &OMCI{
- TransactionID: 0x2468,
- MessageType: DownloadSectionRequestWithResponseType,
- // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // Length: 0x28, // Optional, defaults to 40 octets
- }
- sectionData, genErr := stringToPacket("01020304050607080910111213141516171819202122232425262728293031")
- assert.Nil(t, genErr)
- assert.NotNil(t, sectionData)
- assert.Equal(t, MaxDownloadSectionLength, len(sectionData))
-
- request := &DownloadSectionRequest{
- MeBasePacket: MeBasePacket{
- EntityClass: me.SoftwareImageClassID,
- EntityInstance: 0x0001, // Default is zero, here we want image 1
- },
- SectionNumber: 0xcc,
- SectionData: sectionData,
- }
- // 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 TestDownloadSectionResponseDecode(t *testing.T) {
- goodMessage := "0022340a00070001061f00000000000000000000000000000000000000000000000000000000000000000028"
- 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, omciMsg.TransactionID, uint16(0x0022))
- assert.Equal(t, omciMsg.MessageType, DownloadSectionResponseType)
- assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- assert.Equal(t, omciMsg.Length, uint16(40))
-
- msgLayer := packet.Layer(LayerTypeDownloadSectionResponse)
-
- assert.NotNil(t, msgLayer)
-
- response, ok2 := msgLayer.(*DownloadSectionResponse)
- assert.True(t, ok2)
- assert.NotNil(t, response)
- assert.Equal(t, me.DeviceBusy, response.Result)
- assert.Equal(t, byte(0x1f), response.SectionNumber)
-
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-func TestDownloadSectionResponseSerialize(t *testing.T) {
- goodMessage := "0022340a00070001061f00000000000000000000000000000000000000000000000000000000000000000028"
-
- omciLayer := &OMCI{
- TransactionID: 0x0022,
- MessageType: DownloadSectionResponseType,
- // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // Length: 0x28, // Optional, defaults to 40 octets
- }
- request := &DownloadSectionResponse{
- MeBasePacket: MeBasePacket{
- EntityClass: me.SoftwareImageClassID,
- EntityInstance: 1,
- },
- Result: me.DeviceBusy,
- SectionNumber: 0x1f,
- }
- // 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 TestEndSoftwareDownloadRequestDecode(t *testing.T) {
- //
- // 8100 55 0a 0007 0001 ff92a226 000f4240 01 0001 00000000000000000000000000000000000000000000000028
- //
- goodMessage := "8100550a00070001ff92a226000f424001000100000000000000000000000000000000000000000000000028"
- 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, omciMsg.TransactionID, uint16(0x8100))
- assert.Equal(t, omciMsg.MessageType, EndSoftwareDownloadRequestType)
- assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- assert.Equal(t, omciMsg.Length, uint16(40))
-
- msgLayer := packet.Layer(LayerTypeEndSoftwareDownloadRequest)
- assert.NotNil(t, msgLayer)
-
- request, ok2 := msgLayer.(*EndSoftwareDownloadRequest)
- assert.True(t, ok2)
- assert.NotNil(t, request)
- assert.Equal(t, uint32(0xff92a226), request.CRC32)
- assert.Equal(t, uint32(0x000f4240), request.ImageSize)
- assert.Equal(t, byte(1), request.NumberOfInstances)
- assert.Equal(t, 1, len(request.ImageInstances))
- assert.Equal(t, uint16(1), request.ImageInstances[0])
-
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-func TestEndSoftwareDownloadRequestSerialize(t *testing.T) {
- // 8100 55 0a 0007 0001 ff92a226 000f4240 01 0001 00000000000000000000000000000000000000000000000028
- goodMessage := "8100550a00070001ff92a226000f424001000100000000000000000000000000000000000000000000000028"
-
- omciLayer := &OMCI{
- TransactionID: 0x8100,
- MessageType: EndSoftwareDownloadRequestType,
- // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // Length: 0x28, // Optional, defaults to 40 octets
- }
- request := &EndSoftwareDownloadRequest{
- MeBasePacket: MeBasePacket{
- EntityClass: me.SoftwareImageClassID,
- EntityInstance: 0x0001, // Default is zero, here we want image 1
- },
- CRC32: 0xff92a226,
- ImageSize: 1000000,
- NumberOfInstances: 1,
- ImageInstances: []uint16{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.NoError(t, err)
-
- outgoingPacket := buffer.Bytes()
- reconstituted := packetToString(outgoingPacket)
- assert.Equal(t, strings.ToLower(goodMessage), reconstituted)
-}
-
-func TestEndSoftwareDownloadResponseDecode(t *testing.T) {
- // 8123 35 0a 0007 0001 06 0000000000000000000000000000000000000000000000000000000000000000000028
- goodMessage := "8123350a00070001060000000000000000000000000000000000000000000000000000000000000000000028"
- 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, omciMsg.TransactionID, uint16(0x8123))
- assert.Equal(t, omciMsg.MessageType, EndSoftwareDownloadResponseType)
- assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- assert.Equal(t, omciMsg.Length, uint16(40))
-
- msgLayer := packet.Layer(LayerTypeEndSoftwareDownloadResponse)
- assert.NotNil(t, msgLayer)
-
- response, ok2 := msgLayer.(*EndSoftwareDownloadResponse)
- assert.True(t, ok2)
- assert.NotNil(t, response)
- assert.Equal(t, me.DeviceBusy, response.Result)
- assert.Equal(t, byte(0), response.NumberOfInstances)
- assert.Nil(t, response.MeResults)
-
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-func TestEndSoftwareDownloadResponseSerialize(t *testing.T) {
- goodMessage := "8456350a00070000010000000000000000000000000000000000000000000000000000000000000000000028"
-
- omciLayer := &OMCI{
- TransactionID: 0x8456,
- MessageType: EndSoftwareDownloadResponseType,
- // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // Length: 0x28, // Optional, defaults to 40 octets
- }
- request := &EndSoftwareDownloadResponse{
- MeBasePacket: MeBasePacket{
- EntityClass: me.SoftwareImageClassID,
- // Default is zero
- },
- Result: me.ProcessingError,
- NumberOfInstances: 0,
- }
- // 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 TestActivateSoftwareRequestDecode(t *testing.T) {
- // TODO: Need to complete implementation & debug this
- //goodMessage := "0000560a00070001000000000000000000000000000000000000000000000000000000000000000000000028"
- //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, omciMsg.TransactionID, uint16(0x0))
- //assert.Equal(t, omciMsg.MessageType, ActivateSoftwareRequestType)
- //assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- //assert.Equal(t, omciMsg.Length, uint16(40))
- //
- //msgLayer := packet.Layer(LayerTypeActivateSoftwareRequest)
- //assert.NotNil(t, msgLayer)
- //
- //request, ok2 := msgLayer.(*ActivateSoftwareRequest)
- //assert.True(t, ok2)
- //assert.NotNil(t, request)
- //
- //// Verify string output for message
- //packetString := packet.String()
- //assert.NotZero(t, len(packetString))
-}
-
-func TestActivateSoftwareRequestSerialize(t *testing.T) {
- // TODO: Need to complete implementation & debug this
- //goodMessage := "0000560a00070001000000000000000000000000000000000000000000000000000000000000000000000028"
- //
- //omciLayer := &OMCI{
- // TransactionID: 0x01,
- // MessageType: ActivateSoftwareRequestType,
- // // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // // Length: 0x28, // Optional, defaults to 40 octets
- //}
- //request := &ActivateSoftwareRequest{
- // MeBasePacket: MeBasePacket{
- // EntityClass: OnuDataClassID,
- // // Default Instance ID is 0
- // },
- //}
- //// 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 TestActivateSoftwareResponseDecode(t *testing.T) {
- // TODO: Need to complete implementation & debug this
- //goodMessage := ""
- //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, omciMsg.TransactionID, uint16(0x0))
- //assert.Equal(t, omciMsg.MessageType, ActivateSoftwareResponseType)
- //assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- //assert.Equal(t, omciMsg.Length, uint16(40))
- //
- //msgLayer := packet.Layer(LayerTypeActivateSoftwareResponse)
- //
- //assert.NotNil(t, msgLayer)
- //
- //response, ok2 := msgLayer.(*ActivateSoftwareResponse)
- //assert.True(t, ok2)
- //assert.NotNil(t, response)
- //
- //// Verify string output for message
- //packetString := packet.String()
- //assert.NotZero(t, len(packetString))
-}
-
-func TestActivateSoftwareResponseSerialize(t *testing.T) {
- // TODO: Need to complete implementation & debug this
- //goodMessage := ""
- //
- //omciLayer := &OMCI{
- // TransactionID: 0x01,
- // MessageType: ActivateSoftwareResponseType,
- // // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // // Length: 0x28, // Optional, defaults to 40 octets
- //}
- //request := &ActivateSoftwareResponse{
- // MeBasePacket: MeBasePacket{
- // EntityClass: OnuDataClassID,
- // // Default Instance ID is 0
- // },
- //}
- //// 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 TestCommitSoftwareRequestDecode(t *testing.T) {
- goodMessage := "0011570a00070001000000000000000000000000000000000000000000000000000000000000000000000028"
- 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, omciMsg.TransactionID, uint16(0x11))
- assert.Equal(t, omciMsg.MessageType, CommitSoftwareRequestType)
- assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- assert.Equal(t, omciMsg.Length, uint16(40))
-
- msgLayer := packet.Layer(LayerTypeCommitSoftwareRequest)
- assert.NotNil(t, msgLayer)
-
- request, ok2 := msgLayer.(*CommitSoftwareRequest)
- assert.True(t, ok2)
- assert.NotNil(t, request)
- assert.Equal(t, uint16(1), request.MeBasePacket.EntityInstance)
-
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-func TestCommitSoftwareRequestSerialize(t *testing.T) {
- goodMessage := "0044570a00070001000000000000000000000000000000000000000000000000000000000000000000000028"
-
- omciLayer := &OMCI{
- TransactionID: 0x44,
- MessageType: CommitSoftwareRequestType,
- // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // Length: 0x28, // Optional, defaults to 40 octets
- }
- request := &CommitSoftwareRequest{
- MeBasePacket: MeBasePacket{
- EntityClass: me.SoftwareImageClassID,
- EntityInstance: 1, // Default Instance ID is 0
- },
- }
- // 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 TestCommitSoftwareResponseDecode(t *testing.T) {
- goodMessage := "00aa370a00070001060000000000000000000000000000000000000000000000000000000000000000000028"
- 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, omciMsg.TransactionID, uint16(0xaa))
- assert.Equal(t, omciMsg.MessageType, CommitSoftwareResponseType)
- assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- assert.Equal(t, omciMsg.Length, uint16(40))
-
- msgLayer := packet.Layer(LayerTypeCommitSoftwareResponse)
-
- assert.NotNil(t, msgLayer)
-
- response, ok2 := msgLayer.(*CommitSoftwareResponse)
- assert.True(t, ok2)
- assert.NotNil(t, response)
- assert.Equal(t, uint16(1), response.MeBasePacket.EntityInstance)
- assert.Equal(t, me.DeviceBusy, response.Result)
-
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-func TestCommitSoftwareResponseSerialize(t *testing.T) {
- goodMessage := "8001370a00070001060000000000000000000000000000000000000000000000000000000000000000000028"
-
- omciLayer := &OMCI{
- TransactionID: 0x8001,
- MessageType: CommitSoftwareResponseType,
- // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // Length: 0x28, // Optional, defaults to 40 octets
- }
- request := &CommitSoftwareResponse{
- MeBasePacket: MeBasePacket{
- EntityClass: me.SoftwareImageClassID,
- EntityInstance: 1, // Default Instance ID is 0
- },
- Result: me.DeviceBusy,
- }
- // 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 TestMibResetResponseDecode(t *testing.T) {
- goodMessage := "00012F0A00020000000000000000000000000000000000000000000000000000000000000000000000000028"
- 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, omciMsg.MessageType, MibResetResponseType)
- assert.Equal(t, omciMsg.Length, uint16(40))
-
- msgLayer := packet.Layer(LayerTypeMibResetResponse)
-
- assert.NotNil(t, msgLayer)
-
- response, ok2 := msgLayer.(*MibResetResponse)
- assert.True(t, ok2)
- assert.NotNil(t, response)
-
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-func TestMibResetResponseSerialize(t *testing.T) {
- goodMessage := "00012F0A00020000000000000000000000000000000000000000000000000000000000000000000000000028"
-
- omciLayer := &OMCI{
- TransactionID: 0x01,
- MessageType: MibResetResponseType,
- // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // Length: 0x28, // Optional, defaults to 40 octets
- }
- request := &MibResetResponse{
- MeBasePacket: MeBasePacket{
- EntityClass: me.OnuDataClassID,
- // Default Instance ID is 0
- },
- }
- // 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 TestSynchronizeTimeRequestDecode(t *testing.T) {
- goodMessage := "0109580a0100000007e20c0101301b0000000000000000000000000000000000000000000000000000000028"
- 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, omciMsg.MessageType, SynchronizeTimeRequestType)
- assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- assert.Equal(t, omciMsg.Length, uint16(40))
-
- msgLayer := packet.Layer(LayerTypeSynchronizeTimeRequest)
- assert.NotNil(t, msgLayer)
-
- request, ok2 := msgLayer.(*SynchronizeTimeRequest)
- assert.True(t, ok2)
- assert.NotNil(t, request)
- assert.Equal(t, request.Year, uint16(2018))
- assert.Equal(t, request.Month, uint8(12))
- assert.Equal(t, request.Day, uint8(1))
- assert.Equal(t, request.Hour, uint8(01))
- assert.Equal(t, request.Minute, uint8(48))
- assert.Equal(t, request.Second, uint8(27))
-
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-func TestSynchronizeTimeRequestSerialize(t *testing.T) {
- goodMessage := "0109580a0100000007e20c0101301b0000000000000000000000000000000000000000000000000000000028"
-
- omciLayer := &OMCI{
- TransactionID: 0x0109,
- MessageType: SynchronizeTimeRequestType,
- // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // Length: 0x28, // Optional, defaults to 40 octets
- }
- request := &SynchronizeTimeRequest{
- MeBasePacket: MeBasePacket{
- EntityClass: me.OnuGClassID,
- // Default Instance ID is 0
- },
- Year: uint16(2018),
- Month: uint8(12),
- Day: uint8(1),
- Hour: uint8(01),
- Minute: uint8(48),
- Second: uint8(27),
- }
- // 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 TestSynchronizeTimeResponseDecode(t *testing.T) {
- goodMessage := "0109380a01000000000000000000000000000000000000000000000000000000000000000000000000000028"
- 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, omciMsg.MessageType, SynchronizeTimeResponseType)
- assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- assert.Equal(t, omciMsg.Length, uint16(40))
-
- msgLayer := packet.Layer(LayerTypeSynchronizeTimeResponse)
- assert.NotNil(t, msgLayer)
-
- response, ok2 := msgLayer.(*SynchronizeTimeResponse)
- assert.True(t, ok2)
- assert.NotNil(t, response)
-
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-func TestSynchronizeTimeResponseSerialize(t *testing.T) {
- goodMessage := "0109380a01000000000000000000000000000000000000000000000000000000000000000000000000000028"
-
- omciLayer := &OMCI{
- TransactionID: 0x0109,
- MessageType: SynchronizeTimeResponseType,
- // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // Length: 0x28, // Optional, defaults to 40 octets
- }
- request := &SynchronizeTimeResponse{
- MeBasePacket: MeBasePacket{
- EntityClass: me.OnuGClassID,
- EntityInstance: uint16(0),
- },
- Result: me.Success,
- SuccessResults: uint8(0),
- }
- // 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 TestRebootRequestDecode(t *testing.T) {
- goodMessage := "0001590a01000000010000000000000000000000000000000000000000000000000000000000000000000028"
- 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, omciMsg.TransactionID, uint16(0x0001))
- assert.Equal(t, omciMsg.MessageType, RebootRequestType)
- assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- assert.Equal(t, omciMsg.Length, uint16(40))
-
- msgLayer := packet.Layer(LayerTypeRebootRequest)
- assert.NotNil(t, msgLayer)
-
- request, ok2 := msgLayer.(*RebootRequest)
- assert.True(t, ok2)
- assert.NotNil(t, request)
- assert.Equal(t, request.EntityClass, me.OnuGClassID)
- assert.Equal(t, request.EntityInstance, uint16(0))
- assert.Equal(t, request.RebootCondition, uint8(1))
-
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-func TestRebootRequestSerialize(t *testing.T) {
- goodMessage := "0001590a01000000020000000000000000000000000000000000000000000000000000000000000000000028"
-
- omciLayer := &OMCI{
- TransactionID: 0x0001,
- MessageType: RebootRequestType,
- // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // Length: 0x28, // Optional, defaults to 40 octets
- }
- request := &RebootRequest{
- MeBasePacket: MeBasePacket{
- EntityClass: me.OnuGClassID,
- // Default Instance ID is 0
- },
- RebootCondition: uint8(2),
- }
- // 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 TestRebootResponseDecode(t *testing.T) {
- goodMessage := "023c390a01000000000000000000000000000000000000000000000000000000000000000000000000000028"
- 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, omciMsg.TransactionID, uint16(0x023c))
- assert.Equal(t, omciMsg.MessageType, RebootResponseType)
- assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- assert.Equal(t, omciMsg.Length, uint16(40))
-
- msgLayer := packet.Layer(LayerTypeRebootResponse)
- assert.NotNil(t, msgLayer)
-
- response, ok2 := msgLayer.(*RebootResponse)
- assert.True(t, ok2)
- assert.NotNil(t, response)
- assert.Equal(t, response.EntityClass, me.OnuGClassID)
- assert.Equal(t, response.EntityInstance, uint16(0))
- assert.Equal(t, response.Result, me.Success)
-
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-func TestRebootResponseSerialize(t *testing.T) {
- goodMessage := "023c390a01000000060000000000000000000000000000000000000000000000000000000000000000000028"
-
- omciLayer := &OMCI{
- TransactionID: 0x023c,
- MessageType: RebootResponseType,
- // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // Length: 0x28, // Optional, defaults to 40 octets
- }
- request := &RebootResponse{
- MeBasePacket: MeBasePacket{
- EntityClass: me.OnuGClassID,
- EntityInstance: uint16(0),
- },
- Result: me.DeviceBusy,
- }
- // 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 TestGetNextRequestDecode(t *testing.T) {
- goodMessage := "285e5a0a00ab0202040000010000000000000000000000000000000000000000000000000000000000000028"
- 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, omciMsg.TransactionID, uint16(0x285e))
- assert.Equal(t, omciMsg.MessageType, GetNextRequestType)
- assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- assert.Equal(t, omciMsg.Length, uint16(40))
-
- msgLayer := packet.Layer(LayerTypeGetNextRequest)
- assert.NotNil(t, msgLayer)
-
- request, ok2 := msgLayer.(*GetNextRequest)
- assert.True(t, ok2)
- assert.NotNil(t, request)
- assert.Equal(t, request.EntityClass, me.ExtendedVlanTaggingOperationConfigurationDataClassID)
- assert.Equal(t, request.EntityInstance, uint16(0x0202))
- assert.Equal(t, request.AttributeMask, uint16(0x0400))
- assert.Equal(t, request.SequenceNumber, uint16(1))
-
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-func TestGetNextRequestSerialize(t *testing.T) {
- goodMessage := "285e5a0a00ab0202040000010000000000000000000000000000000000000000000000000000000000000028"
-
- omciLayer := &OMCI{
- TransactionID: 0x285e,
- MessageType: GetNextRequestType,
- // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // Length: 0x28, // Optional, defaults to 40 octets
- }
- request := &GetNextRequest{
- MeBasePacket: MeBasePacket{
- EntityClass: me.ExtendedVlanTaggingOperationConfigurationDataClassID,
- EntityInstance: uint16(0x0202),
- },
- AttributeMask: uint16(0x0400),
- SequenceNumber: uint16(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.NoError(t, err)
-
- outgoingPacket := buffer.Bytes()
- reconstituted := packetToString(outgoingPacket)
- assert.Equal(t, strings.ToLower(goodMessage), reconstituted)
-}
-
-func TestGetNextResponseDecode(t *testing.T) {
- goodMessage := "285e3a0a00ab0202000400080334000000000000000000000000000000000000000000000000000000000028"
-
- 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, omciMsg.TransactionID, uint16(0x285e))
- assert.Equal(t, omciMsg.MessageType, GetNextResponseType)
- assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- assert.Equal(t, omciMsg.Length, uint16(40))
-
- msgLayer := packet.Layer(LayerTypeGetNextResponse)
- assert.NotNil(t, msgLayer)
-
- vlanOpTable := []byte{0x08, 0x03, 0x34, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
-
- response, ok2 := msgLayer.(*GetNextResponse)
- assert.True(t, ok2)
- assert.NotNil(t, response)
- assert.Equal(t, me.ExtendedVlanTaggingOperationConfigurationDataClassID, response.EntityClass)
- assert.Equal(t, uint16(0x0202), response.EntityInstance)
- assert.Equal(t, me.Success, response.Result)
- assert.Equal(t, uint16(0x0400), response.AttributeMask)
-
- // For GetNextResponse frames, caller is responsible for trimming last packet to remaining
- // size
- expectedOctets := 16
- value := response.Attributes["ReceivedFrameVlanTaggingOperationTable"]
- assert.Equal(t, vlanOpTable, value.([]byte)[:expectedOctets])
-
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-func TestGetNextResponseSerialize(t *testing.T) {
- goodMessage := "285e3a0a00ab0202000400080334000000000000000000000000000000000000000000000000000000000028"
-
- omciLayer := &OMCI{
- TransactionID: 0x285e,
- MessageType: GetNextResponseType,
- // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // Length: 0x28, // Optional, defaults to 40 octets
- }
- vlanOpTable := []byte{0x08, 0x03, 0x34, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
-
- request := &GetNextResponse{
- MeBasePacket: MeBasePacket{
- EntityClass: me.ExtendedVlanTaggingOperationConfigurationDataClassID,
- EntityInstance: uint16(0x0202),
- },
- Result: me.Success,
AttributeMask: uint16(0x0400),
- Attributes: me.AttributeValueMap{"ReceivedFrameVlanTaggingOperationTable": vlanOpTable},
- }
- // 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: Create request/response tests for all of the following types -> SetTable
-
-func TestAlarmNotificationDecode(t *testing.T) {
- goodMessage := "0000100a000b0104800000000000000000000000000000000000000000000000000000000000000500000028"
- 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, omciMsg.TransactionID, uint16(0x0))
- assert.Equal(t, omciMsg.MessageType, AlarmNotificationType)
- assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- assert.Equal(t, omciMsg.Length, uint16(40))
-
- msgLayer := packet.Layer(LayerTypeAlarmNotification)
- assert.NotNil(t, msgLayer)
-
- request, ok2 := msgLayer.(*AlarmNotificationMsg)
- assert.True(t, ok2)
- assert.NotNil(t, request)
- assert.Equal(t, request.EntityClass, me.PhysicalPathTerminationPointEthernetUniClassID)
- assert.Equal(t, request.EntityInstance, uint16(0x104))
- assert.Equal(t, request.AlarmBitmap, [28]byte{
- 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- })
- assert.Equal(t, request.AlarmSequenceNumber, byte(5))
-
- // Active/Clear tests
- active, err2 := request.IsAlarmActive(0)
- clear, err3 := request.IsAlarmClear(0)
- assert.Nil(t, err2)
- assert.Nil(t, err3)
- assert.True(t, active)
- assert.False(t, clear)
-
- // Active/Clear for undefined alarm bits
- active, err2 = request.IsAlarmActive(1)
- clear, err3 = request.IsAlarmClear(1)
- assert.NotNil(t, err2)
- assert.NotNil(t, err3)
-
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-func TestInvalidClassAlarmNotificationDecode(t *testing.T) {
- // Choosing GalEthernetProfile (272) since it does not support alarms, show we should
- // file the decode
- badMessage := "0000100a01100104800000000000000000000000000000000000000000000000000000000000000500000028"
- data, err := stringToPacket(badMessage)
- 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, omciMsg.TransactionID, uint16(0x0))
- assert.Equal(t, omciMsg.MessageType, AlarmNotificationType)
- assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- assert.Equal(t, omciMsg.Length, uint16(40))
-
- msgLayer := packet.Layer(LayerTypeAlarmNotification)
- assert.Nil(t, msgLayer)
-
- request, ok2 := msgLayer.(*AlarmNotificationMsg)
- assert.False(t, ok2)
- assert.Nil(t, request)
-}
-
-func TestUnknownsMeAlarmNotificationDecode(t *testing.T) {
- // Choosing class ID 22 since it is in the G.988 class ID space and is reserved
- goodMessage := "0000100a00160104800000000000000000000000000000000000000000000000000000000000000500000028"
- 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, omciMsg.TransactionID, uint16(0x0))
- assert.Equal(t, omciMsg.MessageType, AlarmNotificationType)
- assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- assert.Equal(t, omciMsg.Length, uint16(40))
-
- msgLayer := packet.Layer(LayerTypeAlarmNotification)
- assert.NotNil(t, msgLayer)
-
- request, ok2 := msgLayer.(*AlarmNotificationMsg)
- assert.True(t, ok2)
- assert.NotNil(t, request)
- assert.Equal(t, request.EntityClass, me.ClassID(22))
- assert.Equal(t, request.EntityInstance, uint16(0x104))
- assert.Equal(t, request.AlarmBitmap, [28]byte{
- 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- })
- assert.Equal(t, request.AlarmSequenceNumber, byte(5))
-}
-
-func TestVendorSpecificAlarmNotificationDecode(t *testing.T) {
- // Choosing class ID 255 since it is in the first vendor specific class ID space
- goodMessage := "0000100a00FF0104800000000000000000000000000000000000000000000000000000000000000500000028"
- 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, omciMsg.TransactionID, uint16(0x0))
- assert.Equal(t, omciMsg.MessageType, AlarmNotificationType)
- assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- assert.Equal(t, omciMsg.Length, uint16(40))
-
- msgLayer := packet.Layer(LayerTypeAlarmNotification)
- assert.NotNil(t, msgLayer)
-
- request, ok2 := msgLayer.(*AlarmNotificationMsg)
- assert.True(t, ok2)
- assert.NotNil(t, request)
- assert.Equal(t, request.EntityClass, me.ClassID(255))
- assert.Equal(t, request.EntityInstance, uint16(0x104))
- assert.Equal(t, request.AlarmBitmap, [28]byte{
- 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- })
- assert.Equal(t, request.AlarmSequenceNumber, byte(5))
-}
-
-func TestAlarmNotificationSerialize(t *testing.T) {
- goodMessage := "0000100a000b0104800000000000000000000000000000000000000000000000000000000000000500000028"
-
- omciLayer := &OMCI{
- TransactionID: 0,
- MessageType: AlarmNotificationType,
- // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // Length: 0x28, // Optional, defaults to 40 octets
- }
- request := &AlarmNotificationMsg{
- MeBasePacket: MeBasePacket{
- EntityClass: me.PhysicalPathTerminationPointEthernetUniClassID,
- EntityInstance: uint16(0x104),
- },
- AlarmBitmap: [28]byte{
- 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- },
- AlarmSequenceNumber: byte(5),
- }
- // 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 TestAttributeValueChangeDecode(t *testing.T) {
- goodMessage := "0000110a0007000080004d4c2d33363236000000000000000000000000000000000000000000000000000028"
- 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, omciMsg.TransactionID, uint16(0x0))
- assert.Equal(t, omciMsg.MessageType, AttributeValueChangeType)
- assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- assert.Equal(t, omciMsg.Length, uint16(40))
-
- msgLayer := packet.Layer(LayerTypeAttributeValueChange)
- assert.NotNil(t, msgLayer)
-
- request, ok2 := msgLayer.(*AttributeValueChangeMsg)
- assert.True(t, ok2)
- assert.NotNil(t, request)
- assert.Equal(t, request.AttributeMask, uint16(0x8000))
- assert.Equal(t, request.EntityClass, me.SoftwareImageClassID)
- assert.Equal(t, request.EntityInstance, uint16(0))
- assert.Equal(t, request.Attributes["Version"], []byte{
- 0x4d, 0x4c, 0x2d, 0x33, 0x36, 0x32, 0x36,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})
-
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-func TestAttributeValueChangeSerialize(t *testing.T) {
- goodMessage := "0000110a0007000080004d4c2d33363236000000000000000000000000000000000000000000000000000028"
-
- omciLayer := &OMCI{
- TransactionID: 0,
- MessageType: AttributeValueChangeType,
- // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
- // Length: 0x28, // Optional, defaults to 40 octets
- }
- request := &AttributeValueChangeMsg{
- MeBasePacket: MeBasePacket{
- EntityClass: me.SoftwareImageClassID,
- EntityInstance: uint16(0),
- },
- AttributeMask: uint16(0x8000),
Attributes: me.AttributeValueMap{
- "Version": []byte{
- 0x4d, 0x4c, 0x2d, 0x33, 0x36, 0x32, 0x36,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- },
- },
+ "ImageHash": toOctets("AAECAwQFBgcICQoLDA0ODw==")}, // 0->f octets
}
// Test serialization back to former string
var options gopacket.SerializeOptions
@@ -3000,1541 +313,3 @@
reconstituted := packetToString(outgoingPacket)
assert.Equal(t, strings.ToLower(goodMessage), reconstituted)
}
-
-func TestJira3769(t *testing.T) {
- // VOL-3769. Error parsing get response with processing error and large mask
- sampleMessage := "035e290a0101000001FFFC000000000000000000000000000000000000000000000000000000000000000028"
- data, err := stringToPacket(sampleMessage)
- 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, omciMsg.TransactionID, uint16(0x035e))
- assert.Equal(t, omciMsg.MessageType, GetResponseType)
- assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- assert.Equal(t, omciMsg.Length, uint16(40))
-
- // before bugfix for this JIRA, the following call returned 'nil' Failure was
- // occurring before this at during getResponse decoding.
- msgLayer := packet.Layer(LayerTypeGetResponse)
- assert.NotNil(t, msgLayer)
-
- response, ok2 := msgLayer.(*GetResponse)
- assert.True(t, ok2)
- assert.NotNil(t, response)
- assert.Equal(t, response.Result, me.ProcessingError)
- assert.Equal(t, response.AttributeMask, uint16(0xFFFC))
-}
-
-func TestJira3863(t *testing.T) {
- goodMessage := "81a9240a013880010700000000000000000000000000000000000000000000000000000000000000000000283f73ddea"
- 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)
-
- msgLayer := packet.Layer(LayerTypeCreateResponse)
- assert.NotNil(t, msgLayer)
-
- // FEC PM ME not in class map so the following was failing (ok2 false)
- response, ok2 := msgLayer.(*CreateResponse)
- assert.True(t, ok2)
- assert.NotNil(t, response)
-
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-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.Equal(t, omciMsg.TransactionID, uint16(0x035e))
- assert.Equal(t, omciMsg.MessageType, GetRequestType)
- assert.Equal(t, omciMsg.DeviceIdentifier, ExtendedIdent)
- assert.Equal(t, omciMsg.Length, uint16(2))
-
- msgLayer := packet.Layer(LayerTypeGetRequest)
- assert.NotNil(t, msgLayer)
-
- request, ok2 := msgLayer.(*GetRequest)
- assert.True(t, ok2)
- assert.NotNil(t, request)
-
- //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, omciErr.StatusCode(), me.Success)
-
- 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.Equal(t, omciMsg.TransactionID, uint16(0x035e))
- assert.Equal(t, omciMsg.MessageType, GetResponseType)
- assert.Equal(t, omciMsg.DeviceIdentifier, ExtendedIdent)
- assert.Equal(t, omciMsg.Length, uint16(msgLength))
-
- msgLayer := packet.Layer(LayerTypeGetResponse)
- assert.NotNil(t, msgLayer)
-
- response, ok2 := msgLayer.(*GetResponse)
- assert.True(t, ok2)
- assert.NotNil(t, response)
- assert.Equal(t, response.Result, me.Success)
- assert.Equal(t, response.AttributeMask, uint16(attributeMask))
- assert.Equal(t, response.FailedAttributeMask, uint16(0))
- assert.Equal(t, response.UnsupportedAttributeMask, uint16(0))
-
- assert.Equal(t, response.Attributes["EquipmentId"], toOctets("AAAAAAAAAAAAAAAAAAAAAAAAAAA="))
- assert.Equal(t, response.Attributes["OpticalNetworkUnitManagementAndControlChannelOmccVersion"], byte(0xb4)) // )
- assert.Equal(t, response.Attributes["VendorProductCode"], uint16(0x1234))
- assert.Equal(t, response.Attributes["SecurityCapability"], byte(1))
- assert.Equal(t, response.Attributes["SecurityMode"], byte(1))
- assert.Equal(t, response.Attributes["TotalPriorityQueueNumber"], uint16(0x5678))
- assert.Equal(t, response.Attributes["TotalTrafficSchedulerNumber"], byte(0x44))
- assert.Equal(t, response.Attributes["Deprecated"], byte(1))
- assert.Equal(t, response.Attributes["TotalGemPortIdNumber"], uint16(0x55aa))
- assert.Equal(t, response.Attributes["Sysuptime"], uint32(0xC4108011))
- assert.Equal(t, response.Attributes["ConnectivityCapability"], uint16(0x6))
- assert.Equal(t, response.Attributes["CurrentConnectivityMode"], byte(6))
- assert.Equal(t, response.Attributes["QualityOfServiceQosConfigurationFlexibility"], uint16(2))
- assert.Equal(t, response.Attributes["PriorityQueueScaleFactor"], uint16(0x1234))
-
- // 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)
-}
-
-// 1 2 3 4
-// 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4
-// 0008140a00070001 - Download section, AR=0
-// cc - Section 0xcc
-// 01020304050607080910111213141516171819202122232425262728293031
-// 00000028
-func TestExtendedDownloadSectionRequestDecodeNoResponseExpected(t *testing.T) {
- goodMessage := "0008140b00070001"
- payloadFragment := "01020304050607080910111213141516171819202122232425"
- payloadTotal := payloadFragment + payloadFragment + payloadFragment + payloadFragment +
- payloadFragment + payloadFragment + payloadFragment + payloadFragment
- sectionNumber := 0x88
- length := 1 + (8 * 25)
- hdr := fmt.Sprintf("%04x%02x", length, sectionNumber)
- goodMessage += hdr + payloadTotal
- data, err := stringToPacket(goodMessage)
- assert.NoError(t, err)
-
- packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.NoCopy)
- assert.NotNil(t, packet)
- assert.Nil(t, packet.ErrorLayer())
-
- omciLayer := packet.Layer(LayerTypeOMCI)
- assert.NotNil(t, omciLayer)
-
- omciMsg, ok := omciLayer.(*OMCI)
- assert.True(t, ok)
- assert.Equal(t, uint16(0x0008), omciMsg.TransactionID)
- assert.Equal(t, DownloadSectionRequestType, omciMsg.MessageType)
- assert.False(t, omciMsg.ResponseExpected)
- assert.Equal(t, ExtendedIdent, omciMsg.DeviceIdentifier)
- assert.Equal(t, uint16(length), omciMsg.Length)
-
- msgLayer := packet.Layer(LayerTypeDownloadSectionRequest)
- assert.NotNil(t, msgLayer)
-
- request, ok2 := msgLayer.(*DownloadSectionRequest)
- assert.True(t, ok2)
- assert.NotNil(t, request)
- assert.Equal(t, uint8(sectionNumber), request.SectionNumber)
- assert.Equal(t, length-1, len(request.SectionData))
-
- data, err = stringToPacket(payloadTotal)
- assert.NoError(t, err)
- assert.Equal(t, data, request.SectionData[:])
-
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-func TestExtendedDownloadSectionRequestDecodeResponseExpected(t *testing.T) {
- goodMessage := "0008540b00070001"
- payloadFragment := "01020304050607080910111213141516171819202122232425"
- payloadTotal := payloadFragment + payloadFragment + payloadFragment + payloadFragment +
- payloadFragment + payloadFragment + payloadFragment + payloadFragment +
- payloadFragment + payloadFragment + payloadFragment + payloadFragment +
- payloadFragment + payloadFragment + payloadFragment + payloadFragment +
- payloadFragment + payloadFragment + payloadFragment + payloadFragment
- sectionNumber := 0x88
- length := 1 + (20 * 25)
- hdr := fmt.Sprintf("%04x%02x", length, sectionNumber)
- goodMessage += hdr + payloadTotal
- data, err := stringToPacket(goodMessage)
- assert.NoError(t, err)
-
- packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.NoCopy)
- assert.NotNil(t, packet)
- assert.Nil(t, packet.ErrorLayer())
-
- omciLayer := packet.Layer(LayerTypeOMCI)
- assert.NotNil(t, omciLayer)
-
- omciMsg, ok := omciLayer.(*OMCI)
- assert.True(t, ok)
- assert.Equal(t, uint16(0x0008), omciMsg.TransactionID)
- assert.Equal(t, DownloadSectionRequestWithResponseType, omciMsg.MessageType)
- assert.True(t, omciMsg.ResponseExpected)
- assert.Equal(t, ExtendedIdent, omciMsg.DeviceIdentifier)
- assert.Equal(t, uint16(length), omciMsg.Length)
-
- msgLayer := packet.Layer(LayerTypeDownloadSectionRequest)
- assert.NotNil(t, msgLayer)
-
- request, ok2 := msgLayer.(*DownloadSectionRequest)
- assert.True(t, ok2)
- assert.NotNil(t, request)
- assert.Equal(t, uint8(sectionNumber), request.SectionNumber)
- assert.Equal(t, length-1, len(request.SectionData))
-
- data, err = stringToPacket(payloadTotal)
- assert.NoError(t, err)
- assert.Equal(t, data, request.SectionData)
-
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-func TestExtendedDownloadSectionRequestDecodeTruncated(t *testing.T) {
- goodMessage := "0008540b000700010000"
- 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 TestExtendedDownloadSectionRequestSerializeNoResponseExpected(t *testing.T) {
- goodMessage := "0123140b00070001"
- payloadFragment := "01020304050607080910111213141516171819202122232425"
- payloadTotal := payloadFragment + payloadFragment + payloadFragment + payloadFragment +
- payloadFragment + payloadFragment + payloadFragment + payloadFragment
- sectionNumber := 0x84
- length := 1 + (8 * 25)
- hdr := fmt.Sprintf("%04x%02x", length, sectionNumber)
- goodMessage += hdr + payloadTotal
-
- omciLayer := &OMCI{
- TransactionID: 0x0123,
- MessageType: DownloadSectionRequestType,
- DeviceIdentifier: ExtendedIdent,
- }
- sectionData, genErr := stringToPacket(payloadTotal)
- assert.Nil(t, genErr)
- assert.NotNil(t, sectionData)
- assert.Equal(t, len(payloadTotal)/2, len(sectionData))
-
- request := &DownloadSectionRequest{
- MeBasePacket: MeBasePacket{
- EntityClass: me.SoftwareImageClassID,
- EntityInstance: uint16(1),
- Extended: true,
- },
- SectionNumber: byte(sectionNumber),
- SectionData: sectionData,
- }
- // 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 TestExtendedDownloadSectionRequestSerializeResponseExpectedMethod1(t *testing.T) {
- goodMessage := "2468540b00070001"
- payloadFragment := "01020304050607080910111213141516171819202122232425"
- payloadTotal := payloadFragment + payloadFragment + payloadFragment + payloadFragment +
- payloadFragment + payloadFragment + payloadFragment + payloadFragment
- sectionNumber := 0x84
- length := 1 + (8 * 25)
- hdr := fmt.Sprintf("%04x%02x", length, sectionNumber)
- goodMessage += hdr + payloadTotal
-
- omciLayer := &OMCI{
- TransactionID: 0x2468,
- MessageType: DownloadSectionRequestType, // or DownloadSectionRequestWithResponseType
- ResponseExpected: true,
- DeviceIdentifier: ExtendedIdent,
- }
- sectionData, genErr := stringToPacket(payloadTotal)
- assert.Nil(t, genErr)
- assert.NotNil(t, sectionData)
- assert.Equal(t, len(payloadTotal)/2, len(sectionData))
-
- request := &DownloadSectionRequest{
- MeBasePacket: MeBasePacket{
- EntityClass: me.SoftwareImageClassID,
- EntityInstance: uint16(1),
- Extended: true,
- },
- SectionNumber: byte(sectionNumber),
- SectionData: sectionData,
- }
- // 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 TestExtendedDownloadSectionRequestSerializeResponseExpectedMethod2(t *testing.T) {
- goodMessage := "2468540b00070001"
- payloadFragment := "01020304050607080910111213141516171819202122232425"
- payloadTotal := payloadFragment + payloadFragment + payloadFragment + payloadFragment +
- payloadFragment + payloadFragment + payloadFragment + payloadFragment
- sectionNumber := 0x84
- length := 1 + (8 * 25)
- hdr := fmt.Sprintf("%04x%02x", length, sectionNumber)
- goodMessage += hdr + payloadTotal
-
- // In this case, just use the request type with AR response requested already encoded
- omciLayer := &OMCI{
- TransactionID: 0x2468,
- MessageType: DownloadSectionRequestWithResponseType,
- ResponseExpected: true,
- DeviceIdentifier: ExtendedIdent,
- }
- sectionData, genErr := stringToPacket(payloadTotal)
- assert.Nil(t, genErr)
- assert.NotNil(t, sectionData)
- assert.Equal(t, len(payloadTotal)/2, len(sectionData))
-
- request := &DownloadSectionRequest{
- MeBasePacket: MeBasePacket{
- EntityClass: me.SoftwareImageClassID,
- EntityInstance: 0x0001, // Default is zero, here we want image 1
- Extended: true,
- },
- SectionNumber: byte(sectionNumber),
- SectionData: sectionData,
- }
- // 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 TestExtendedDownloadSectionResponseDecode(t *testing.T) {
- goodMessage := "0022340b000700010002061f"
- 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, omciMsg.TransactionID, uint16(0x0022))
- assert.Equal(t, omciMsg.MessageType, DownloadSectionResponseType)
- assert.Equal(t, omciMsg.DeviceIdentifier, ExtendedIdent)
- assert.Equal(t, uint16(2), omciMsg.Length)
-
- msgLayer := packet.Layer(LayerTypeDownloadSectionResponse)
- assert.NotNil(t, msgLayer)
-
- response, ok2 := msgLayer.(*DownloadSectionResponse)
- assert.True(t, ok2)
- assert.NotNil(t, response)
- assert.Equal(t, me.DeviceBusy, response.Result)
- assert.Equal(t, byte(0x1f), response.SectionNumber)
-
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-func TestExtendedDownloadSectionResponseDecodeTruncated(t *testing.T) {
- goodMessage := "0022340b00070001000106"
- 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 TestExtendedDownloadSectionResponseSerialize(t *testing.T) {
- goodMessage := "0022340b000700010002061f"
-
- omciLayer := &OMCI{
- TransactionID: 0x0022,
- MessageType: DownloadSectionResponseType,
- DeviceIdentifier: ExtendedIdent,
- }
- request := &DownloadSectionResponse{
- MeBasePacket: MeBasePacket{
- EntityClass: me.SoftwareImageClassID,
- EntityInstance: 1,
- Extended: true,
- },
- Result: me.DeviceBusy,
- SectionNumber: 0x1f,
- }
- // 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 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.Equal(t, omciMsg.TransactionID, uint16(0x0000))
- assert.Equal(t, omciMsg.MessageType, TestResultType)
- assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- 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.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.Equal(t, omciMsg.TransactionID, uint16(0x0000))
- assert.Equal(t, omciMsg.MessageType, TestResultType)
- assert.Equal(t, omciMsg.DeviceIdentifier, BaselineIdent)
- 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)
-
- // 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: 0x0c, // 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 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.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.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.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)
-
- // 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.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, 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 TestExtendedAlarmNotificationDecode(t *testing.T) {
- // 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8
- goodMessage := "0000100b000b0104001d8000000000000000000000000000000000000000000000000000000005"
- 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(0x0), omciMsg.TransactionID)
- assert.Equal(t, AlarmNotificationType, omciMsg.MessageType)
- assert.Equal(t, ExtendedIdent, omciMsg.DeviceIdentifier)
- assert.Equal(t, uint16(29), omciMsg.Length)
-
- msgLayer := packet.Layer(LayerTypeAlarmNotification)
- assert.NotNil(t, msgLayer)
-
- request, ok2 := msgLayer.(*AlarmNotificationMsg)
- assert.True(t, ok2)
- assert.NotNil(t, request)
- assert.Equal(t, me.PhysicalPathTerminationPointEthernetUniClassID, request.EntityClass)
- assert.Equal(t, uint16(0x104), request.EntityInstance)
- assert.Equal(t, [28]byte{
- 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- }, request.AlarmBitmap)
- assert.Equal(t, byte(5), request.AlarmSequenceNumber)
-
- // Active/Clear tests
- active, err2 := request.IsAlarmActive(0)
- clear, err3 := request.IsAlarmClear(0)
- assert.Nil(t, err2)
- assert.Nil(t, err3)
- assert.True(t, active)
- assert.False(t, clear)
-
- // Active/Clear for undefined alarm bits
- active, err2 = request.IsAlarmActive(1)
- clear, err3 = request.IsAlarmClear(1)
- assert.NotNil(t, err2)
- assert.NotNil(t, err3)
-
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-func TestExtendedAlarmNotificationSerialize(t *testing.T) {
- // 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8
- goodMessage := "0000100b000b0104001d8000000000000000000000000000000000000000000000000000000005"
-
- omciLayer := &OMCI{
- TransactionID: 0,
- MessageType: AlarmNotificationType,
- 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 := &AlarmNotificationMsg{
- MeBasePacket: MeBasePacket{
- EntityClass: me.PhysicalPathTerminationPointEthernetUniClassID,
- EntityInstance: uint16(0x104),
- Extended: true,
- },
- AlarmBitmap: [28]byte{
- 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- },
- AlarmSequenceNumber: byte(5),
- }
- // 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 TestExtendedAttributeValueChangeDecode(t *testing.T) {
- // Software Image Version (14 bytes) AVC
- goodMessage := "0000110b00070000001080004d4c2d3336323600000000000000"
- 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(0x0), omciMsg.TransactionID)
- assert.Equal(t, AttributeValueChangeType, omciMsg.MessageType)
- assert.Equal(t, ExtendedIdent, omciMsg.DeviceIdentifier)
- assert.Equal(t, uint16(2+14), omciMsg.Length)
-
- msgLayer := packet.Layer(LayerTypeAttributeValueChange)
- assert.NotNil(t, msgLayer)
-
- request, ok2 := msgLayer.(*AttributeValueChangeMsg)
- assert.True(t, ok2)
- assert.NotNil(t, request)
- assert.Equal(t, uint16(0x8000), request.AttributeMask)
- assert.Equal(t, me.SoftwareImageClassID, request.EntityClass)
- assert.Equal(t, uint16(0), request.EntityInstance)
- assert.Equal(t, []byte{
- 0x4d, 0x4c, 0x2d, 0x33, 0x36, 0x32, 0x36,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, request.Attributes["Version"])
-
- // Verify string output for message
- packetString := packet.String()
- assert.NotZero(t, len(packetString))
-}
-
-func TestExtendedAttributeValueChangeSerialize(t *testing.T) {
- goodMessage := "0000110b00070000001080004d4c2d3336323600000000000000"
-
- omciLayer := &OMCI{
- TransactionID: 0,
- MessageType: AttributeValueChangeType,
- 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 := &AttributeValueChangeMsg{
- MeBasePacket: MeBasePacket{
- EntityClass: me.SoftwareImageClassID,
- EntityInstance: uint16(0),
- Extended: true,
- },
- AttributeMask: uint16(0x8000),
- Attributes: me.AttributeValueMap{
- "Version": []byte{
- 0x4d, 0x4c, 0x2d, 0x33, 0x36, 0x32, 0x36,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- },
- },
- }
- // 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.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.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.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)
-
- // 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)
-}
-
-func TestGetCurrentDataRequestDecode(t *testing.T) {
- goodMessage := "035e5c0a01a90000004400000000000000000000000000000000000000000000000000000000000000000028"
- 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 := "035e5c0a01a90000004400000000000000000000000000000000000000000000000000000000000000000028"
-
- 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 := "035e3c0a01a90000000044123456781234dbcb432187654321dac1000000000000000000000000000028"
- 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 := "035e3c0a01a90000000044123456781234dbcb432187654321dac10000000000000000000000000000000028"
-
- 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