Gitiles
Code Review Sign In
gerrit.opencord.org / omci-lib-go / refs/tags/v2.1.0 / . / mibupload_test.go
blob: ecb9c9d4f6521b08e3dc39854d2e1837a10262f3 [file] [log] [blame]
Chip Boling610117d2021-09-09 11:24:34 -0500[diff] [blame]1/*
2 * Copyright (c) 2018 - present. Boling Consulting Solutions (bcsw.net)
3 * Copyright 2020-present Open Networking Foundation
4
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8
9 * http://www.apache.org/licenses/LICENSE-2.0
10
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18package omci_test
19
20import (
21 "fmt"
22 "github.com/google/gopacket"
23 . "github.com/opencord/omci-lib-go"
24 me "github.com/opencord/omci-lib-go/generated"
25 "github.com/stretchr/testify/assert"
26 "strings"
27 "testing"
28)
29
30func TestMibUploadRequestDecode(t *testing.T) {
31 goodMessage := "03604d0a00020000000000000000000000000000000000000000000000000000000000000000000000000028"
32 data, err := stringToPacket(goodMessage)
33 assert.NoError(t, err)
34
35 packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.NoCopy)
36 assert.NotNil(t, packet)
37
38 omciLayer := packet.Layer(LayerTypeOMCI)
39 assert.NotNil(t, omciLayer)
40
41 omciMsg, ok := omciLayer.(*OMCI)
42 assert.True(t, ok)
43 assert.NotNil(t, omciMsg)
44 assert.Equal(t, LayerTypeOMCI, omciMsg.LayerType())
45 assert.Equal(t, LayerTypeOMCI, omciMsg.CanDecode())
46 assert.Equal(t, LayerTypeMibUploadRequest, omciMsg.NextLayerType())
47 assert.Equal(t, uint16(0x0360), omciMsg.TransactionID)
48 assert.Equal(t, MibUploadRequestType, omciMsg.MessageType)
49 assert.Equal(t, BaselineIdent, omciMsg.DeviceIdentifier)
50 assert.Equal(t, uint16(40), omciMsg.Length)
51 msgLayer := packet.Layer(LayerTypeMibUploadRequest)
52
53 assert.NotNil(t, msgLayer)
54
55 request, ok2 := msgLayer.(*MibUploadRequest)
56 assert.True(t, ok2)
57 assert.NotNil(t, request)
58 assert.Equal(t, LayerTypeMibUploadRequest, request.LayerType())
59 assert.Equal(t, LayerTypeMibUploadRequest, request.CanDecode())
60 assert.Equal(t, gopacket.LayerTypePayload, request.NextLayerType())
61
62 // Verify string output for message
63 packetString := packet.String()
64 assert.NotZero(t, len(packetString))
65}
66
67func TestMibUploadRequestDecodeExtended(t *testing.T) {
68 goodMessage := "03604d0b000200000000"
69 data, err := stringToPacket(goodMessage)
70 assert.NoError(t, err)
71
72 packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.NoCopy)
73 assert.NotNil(t, packet)
74
75 omciLayer := packet.Layer(LayerTypeOMCI)
76 assert.NotNil(t, omciLayer)
77
78 omciMsg, ok := omciLayer.(*OMCI)
79 assert.True(t, ok)
80 assert.NotNil(t, omciMsg)
81 assert.Equal(t, LayerTypeOMCI, omciMsg.LayerType())
82 assert.Equal(t, LayerTypeOMCI, omciMsg.CanDecode())
83 assert.Equal(t, LayerTypeMibUploadRequest, omciMsg.NextLayerType())
84 assert.Equal(t, uint16(0x0360), omciMsg.TransactionID)
85 assert.Equal(t, MibUploadRequestType, omciMsg.MessageType)
86 assert.Equal(t, ExtendedIdent, omciMsg.DeviceIdentifier)
87 assert.Equal(t, uint16(0), omciMsg.Length)
88 msgLayer := packet.Layer(LayerTypeMibUploadRequest)
89
90 assert.NotNil(t, msgLayer)
91
92 request, ok2 := msgLayer.(*MibUploadRequest)
93 assert.True(t, ok2)
94 assert.NotNil(t, request)
95 assert.Equal(t, LayerTypeMibUploadRequest, request.LayerType())
96 assert.Equal(t, LayerTypeMibUploadRequest, request.CanDecode())
97 assert.Equal(t, gopacket.LayerTypePayload, request.NextLayerType())
98
99 // Verify string output for message
100 packetString := packet.String()
101 assert.NotZero(t, len(packetString))
102}
103
104func TestMibUploadRequestSerialize(t *testing.T) {
105 goodMessage := "03604d0a00020000000000000000000000000000000000000000000000000000000000000000000000000028"
106
107 omciLayer := &OMCI{
108 TransactionID: 0x0360,
109 MessageType: MibUploadRequestType,
110 // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
111 // Length: 0x28, // Optional, defaults to 40 octets
112 }
113 request := &MibUploadRequest{
114 MeBasePacket: MeBasePacket{
115 EntityClass: me.OnuDataClassID,
116 EntityInstance: uint16(0),
117 },
118 }
119 // Test serialization back to former string
120 var options gopacket.SerializeOptions
121 options.FixLengths = true
122
123 buffer := gopacket.NewSerializeBuffer()
124 err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
125 assert.NoError(t, err)
126
127 outgoingPacket := buffer.Bytes()
128 reconstituted := packetToString(outgoingPacket)
129 assert.Equal(t, strings.ToLower(goodMessage), reconstituted)
130}
131
132func TestMibUploadRequestZeroTICSerialize(t *testing.T) {
133 omciLayer := &OMCI{
134 TransactionID: 0x0,
135 MessageType: MibUploadRequestType,
136 // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
137 // Length: 0x28, // Optional, defaults to 40 octets
138 }
139 request := &MibUploadRequest{
140 MeBasePacket: MeBasePacket{
141 EntityClass: me.OnuDataClassID,
142 EntityInstance: uint16(0),
143 },
144 }
145 // Test serialization back to former string
146 var options gopacket.SerializeOptions
147 options.FixLengths = true
148
149 buffer := gopacket.NewSerializeBuffer()
150 err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
151 assert.Error(t, err)
152}
153
154func TestMibUploadRequestSerializeExtended(t *testing.T) {
155 goodMessage := "03604d0b000200000000"
156
157 omciLayer := &OMCI{
158 TransactionID: 0x0360,
159 MessageType: MibUploadRequestType,
160 DeviceIdentifier: ExtendedIdent,
161 }
162 request := &MibUploadRequest{
163 MeBasePacket: MeBasePacket{
164 EntityClass: me.OnuDataClassID,
165 EntityInstance: uint16(0),
166 Extended: true,
167 },
168 }
169 // Test serialization back to former string
170 var options gopacket.SerializeOptions
171 options.FixLengths = true
172
173 buffer := gopacket.NewSerializeBuffer()
174 err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
175 assert.NoError(t, err)
176
177 outgoingPacket := buffer.Bytes()
178 reconstituted := packetToString(outgoingPacket)
179 assert.Equal(t, strings.ToLower(goodMessage), reconstituted)
180}
181
182func TestMibUploadResponseDecode(t *testing.T) {
183 goodMessage := "03602d0a00020000011200000000000000000000000000000000000000000000000000000000000000000028"
184 data, err := stringToPacket(goodMessage)
185 assert.NoError(t, err)
186
187 packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.NoCopy)
188 assert.NotNil(t, packet)
189
190 omciLayer := packet.Layer(LayerTypeOMCI)
191 assert.NotNil(t, omciLayer)
192
193 omciMsg, ok := omciLayer.(*OMCI)
194 assert.True(t, ok)
195 assert.NotNil(t, omciMsg)
196 assert.Equal(t, LayerTypeOMCI, omciMsg.LayerType())
197 assert.Equal(t, LayerTypeOMCI, omciMsg.CanDecode())
198 assert.Equal(t, LayerTypeMibUploadResponse, omciMsg.NextLayerType())
199 assert.Equal(t, uint16(0x0360), omciMsg.TransactionID)
200 assert.Equal(t, MibUploadResponseType, omciMsg.MessageType)
201 assert.Equal(t, BaselineIdent, omciMsg.DeviceIdentifier)
202 assert.Equal(t, uint16(40), omciMsg.Length)
203
204 msgLayer := packet.Layer(LayerTypeMibUploadResponse)
205 assert.NotNil(t, msgLayer)
206
207 response, ok2 := msgLayer.(*MibUploadResponse)
208 assert.True(t, ok2)
209 assert.NotNil(t, response)
210 assert.Equal(t, LayerTypeMibUploadResponse, response.LayerType())
211 assert.Equal(t, LayerTypeMibUploadResponse, response.CanDecode())
212 assert.Equal(t, gopacket.LayerTypePayload, response.NextLayerType())
213 assert.Equal(t, response.NumberOfCommands, uint16(0x112))
214}
215
216func TestMibUploadResponseDecodeExtended(t *testing.T) {
217 goodMessage := "03602d0b0002000000020112"
218 data, err := stringToPacket(goodMessage)
219 assert.NoError(t, err)
220
221 packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.NoCopy)
222 assert.NotNil(t, packet)
223
224 omciLayer := packet.Layer(LayerTypeOMCI)
225 assert.NotNil(t, omciLayer)
226
227 omciMsg, ok := omciLayer.(*OMCI)
228 assert.True(t, ok)
229 assert.NotNil(t, omciMsg)
230 assert.Equal(t, LayerTypeOMCI, omciMsg.LayerType())
231 assert.Equal(t, LayerTypeOMCI, omciMsg.CanDecode())
232 assert.Equal(t, LayerTypeMibUploadResponse, omciMsg.NextLayerType())
233 assert.Equal(t, uint16(0x0360), omciMsg.TransactionID)
234 assert.Equal(t, MibUploadResponseType, omciMsg.MessageType)
235 assert.Equal(t, ExtendedIdent, omciMsg.DeviceIdentifier)
236 assert.Equal(t, uint16(2), omciMsg.Length)
237
238 msgLayer := packet.Layer(LayerTypeMibUploadResponse)
239 assert.NotNil(t, msgLayer)
240
241 response, ok2 := msgLayer.(*MibUploadResponse)
242 assert.True(t, ok2)
243 assert.NotNil(t, response)
244 assert.Equal(t, LayerTypeMibUploadResponse, response.LayerType())
245 assert.Equal(t, LayerTypeMibUploadResponse, response.CanDecode())
246 assert.Equal(t, gopacket.LayerTypePayload, response.NextLayerType())
247 assert.Equal(t, response.NumberOfCommands, uint16(0x112))
248}
249
250func TestMibUploadResponseSerialize(t *testing.T) {
251 goodMessage := "03602d0a00020000011200000000000000000000000000000000000000000000000000000000000000000028"
252
253 omciLayer := &OMCI{
254 TransactionID: 0x0360,
255 MessageType: MibUploadResponseType,
256 // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
257 // Length: 0x28, // Optional, defaults to 40 octets
258 }
259 request := &MibUploadResponse{
260 MeBasePacket: MeBasePacket{
261 EntityClass: me.OnuDataClassID,
262 EntityInstance: uint16(0),
263 },
264 NumberOfCommands: uint16(0x112),
265 }
266 // Test serialization back to former string
267 var options gopacket.SerializeOptions
268 options.FixLengths = true
269
270 buffer := gopacket.NewSerializeBuffer()
271 err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
272 assert.NoError(t, err)
273
274 outgoingPacket := buffer.Bytes()
275 reconstituted := packetToString(outgoingPacket)
276 assert.Equal(t, strings.ToLower(goodMessage), reconstituted)
277}
278
279func TestMibUploadResponseZeroTICSerialize(t *testing.T) {
280 omciLayer := &OMCI{
281 TransactionID: 0x0,
282 MessageType: MibUploadResponseType,
283 // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
284 // Length: 0x28, // Optional, defaults to 40 octets
285 }
286 request := &MibUploadResponse{
287 MeBasePacket: MeBasePacket{
288 EntityClass: me.OnuDataClassID,
289 EntityInstance: uint16(0),
290 },
291 NumberOfCommands: uint16(0x112),
292 }
293 // Test serialization back to former string
294 var options gopacket.SerializeOptions
295 options.FixLengths = true
296
297 buffer := gopacket.NewSerializeBuffer()
298 err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
299 assert.Error(t, err)
300}
301
302func TestMibUploadResponseSerializeExtended(t *testing.T) {
303 goodMessage := "03602d0b0002000000020112"
304
305 omciLayer := &OMCI{
306 TransactionID: 0x0360,
307 MessageType: MibUploadResponseType,
308 DeviceIdentifier: ExtendedIdent,
309 }
310 request := &MibUploadResponse{
311 MeBasePacket: MeBasePacket{
312 EntityClass: me.OnuDataClassID,
313 EntityInstance: uint16(0),
314 Extended: true,
315 },
316 NumberOfCommands: uint16(0x112),
317 }
318 // Test serialization back to former string
319 var options gopacket.SerializeOptions
320 options.FixLengths = true
321
322 buffer := gopacket.NewSerializeBuffer()
323 err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
324 assert.NoError(t, err)
325
326 outgoingPacket := buffer.Bytes()
327 reconstituted := packetToString(outgoingPacket)
328 assert.Equal(t, strings.ToLower(goodMessage), reconstituted)
329}
330
331func TestMibUploadNextRequestDecode(t *testing.T) {
332 goodMessage := "02864e0a00020000003a00000000000000000000000000000000000000000000000000000000000000000028"
333 data, err := stringToPacket(goodMessage)
334 assert.NoError(t, err)
335
336 packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.NoCopy)
337 assert.NotNil(t, packet)
338
339 omciLayer := packet.Layer(LayerTypeOMCI)
340 assert.NotNil(t, omciLayer)
341
342 omciMsg, ok := omciLayer.(*OMCI)
343 assert.True(t, ok)
344 assert.Equal(t, LayerTypeOMCI, omciMsg.LayerType())
345 assert.Equal(t, LayerTypeOMCI, omciMsg.CanDecode())
346 assert.Equal(t, LayerTypeMibUploadNextRequest, omciMsg.NextLayerType())
347 assert.Equal(t, uint16(0x0286), omciMsg.TransactionID)
348 assert.Equal(t, MibUploadNextRequestType, omciMsg.MessageType)
349 assert.Equal(t, BaselineIdent, omciMsg.DeviceIdentifier)
350 assert.Equal(t, uint16(40), omciMsg.Length)
351
352 msgLayer := packet.Layer(LayerTypeMibUploadNextRequest)
353 assert.NotNil(t, msgLayer)
354
355 request, ok2 := msgLayer.(*MibUploadNextRequest)
356 assert.True(t, ok2)
357 assert.NotNil(t, request)
358 assert.Equal(t, LayerTypeMibUploadNextRequest, request.LayerType())
359 assert.Equal(t, LayerTypeMibUploadNextRequest, request.CanDecode())
360 assert.Equal(t, gopacket.LayerTypePayload, request.NextLayerType())
361 assert.Equal(t, uint16(0x3a), request.CommandSequenceNumber)
362
363 // Verify string output for message
364 packetString := packet.String()
365 assert.NotZero(t, len(packetString))
366}
367
368func TestMibUploadNextRequestDecodeExtended(t *testing.T) {
369 goodMessage := "02864e0b000200000002003a"
370 data, err := stringToPacket(goodMessage)
371 assert.NoError(t, err)
372
373 packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.NoCopy)
374 assert.NotNil(t, packet)
375
376 omciLayer := packet.Layer(LayerTypeOMCI)
377 assert.NotNil(t, omciLayer)
378
379 omciMsg, ok := omciLayer.(*OMCI)
380 assert.True(t, ok)
381 assert.Equal(t, LayerTypeOMCI, omciMsg.LayerType())
382 assert.Equal(t, LayerTypeOMCI, omciMsg.CanDecode())
383 assert.Equal(t, LayerTypeMibUploadNextRequest, omciMsg.NextLayerType())
384 assert.Equal(t, uint16(0x0286), omciMsg.TransactionID)
385 assert.Equal(t, MibUploadNextRequestType, omciMsg.MessageType)
386 assert.Equal(t, ExtendedIdent, omciMsg.DeviceIdentifier)
387 assert.Equal(t, uint16(2), omciMsg.Length)
388
389 msgLayer := packet.Layer(LayerTypeMibUploadNextRequest)
390 assert.NotNil(t, msgLayer)
391
392 request, ok2 := msgLayer.(*MibUploadNextRequest)
393 assert.True(t, ok2)
394 assert.NotNil(t, request)
395 assert.Equal(t, LayerTypeMibUploadNextRequest, request.LayerType())
396 assert.Equal(t, LayerTypeMibUploadNextRequest, request.CanDecode())
397 assert.Equal(t, gopacket.LayerTypePayload, request.NextLayerType())
398 assert.Equal(t, uint16(0x3a), request.CommandSequenceNumber)
399
400 // Verify string output for message
401 packetString := packet.String()
402 assert.NotZero(t, len(packetString))
403}
404
405func TestMibUploadNextRequestSerialize(t *testing.T) {
406 goodMessage := "02864e0a00020000003a00000000000000000000000000000000000000000000000000000000000000000028"
407
408 omciLayer := &OMCI{
409 TransactionID: 0x0286,
410 MessageType: MibUploadNextRequestType,
411 // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
412 // Length: 0x28, // Optional, defaults to 40 octets
413 }
414 request := &MibUploadNextRequest{
415 MeBasePacket: MeBasePacket{
416 EntityClass: me.OnuDataClassID,
417 EntityInstance: uint16(0),
418 },
419 CommandSequenceNumber: uint16(0x3a),
420 }
421 // Test serialization back to former string
422 var options gopacket.SerializeOptions
423 options.FixLengths = true
424
425 buffer := gopacket.NewSerializeBuffer()
426 err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
427 assert.NoError(t, err)
428
429 outgoingPacket := buffer.Bytes()
430 reconstituted := packetToString(outgoingPacket)
431 assert.Equal(t, strings.ToLower(goodMessage), reconstituted)
432}
433
434func TestMibUploadNextRequestZeroTICSerialize(t *testing.T) {
435 omciLayer := &OMCI{
436 TransactionID: 0x0,
437 MessageType: MibUploadNextRequestType,
438 // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
439 // Length: 0x28, // Optional, defaults to 40 octets
440 }
441 request := &MibUploadNextRequest{
442 MeBasePacket: MeBasePacket{
443 EntityClass: me.OnuDataClassID,
444 EntityInstance: uint16(0),
445 },
446 CommandSequenceNumber: uint16(0x3a),
447 }
448 // Test serialization back to former string
449 var options gopacket.SerializeOptions
450 options.FixLengths = true
451
452 buffer := gopacket.NewSerializeBuffer()
453 err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
454 assert.Error(t, err)
455}
456
457func TestMibUploadNextRequestSerializeExtended(t *testing.T) {
458 goodMessage := "02864e0b000200000002003a"
459
460 omciLayer := &OMCI{
461 TransactionID: 0x0286,
462 MessageType: MibUploadNextRequestType,
463 DeviceIdentifier: ExtendedIdent,
464 }
465 request := &MibUploadNextRequest{
466 MeBasePacket: MeBasePacket{
467 EntityClass: me.OnuDataClassID,
468 EntityInstance: uint16(0),
469 Extended: true,
470 },
471 CommandSequenceNumber: uint16(0x3a),
472 }
473 // Test serialization back to former string
474 var options gopacket.SerializeOptions
475 options.FixLengths = true
476
477 buffer := gopacket.NewSerializeBuffer()
478 err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
479 assert.NoError(t, err)
480
481 outgoingPacket := buffer.Bytes()
482 reconstituted := packetToString(outgoingPacket)
483 assert.Equal(t, strings.ToLower(goodMessage), reconstituted)
484}
485
486func TestMibUploadNextResponseDecode(t *testing.T) {
487 goodMessage := "02862e0a0002000001150000fff0000000000000000000010100000000010000000000000000000000000028"
488 data, err := stringToPacket(goodMessage)
489 assert.NoError(t, err)
490
491 packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.NoCopy)
492 assert.NotNil(t, packet)
493
494 omciLayer := packet.Layer(LayerTypeOMCI)
495 assert.NotNil(t, omciLayer)
496
497 omciMsg, ok := omciLayer.(*OMCI)
498 assert.True(t, ok)
499 assert.NotNil(t, omciMsg)
500 assert.Equal(t, LayerTypeOMCI, omciMsg.LayerType())
501 assert.Equal(t, LayerTypeOMCI, omciMsg.CanDecode())
502 assert.Equal(t, LayerTypeMibUploadNextResponse, omciMsg.NextLayerType())
503 assert.Equal(t, uint16(0x0286), omciMsg.TransactionID)
504 assert.Equal(t, MibUploadNextResponseType, omciMsg.MessageType)
505 assert.Equal(t, BaselineIdent, omciMsg.DeviceIdentifier)
506 assert.Equal(t, uint16(40), omciMsg.Length)
507
508 msgLayer := packet.Layer(LayerTypeMibUploadNextResponse)
509 assert.NotNil(t, msgLayer)
510
511 response, ok2 := msgLayer.(*MibUploadNextResponse)
512 assert.True(t, ok2)
513 assert.NotNil(t, response)
514 assert.Equal(t, LayerTypeMibUploadNextResponse, response.LayerType())
515 assert.Equal(t, LayerTypeMibUploadNextResponse, response.CanDecode())
516 assert.Equal(t, gopacket.LayerTypePayload, response.NextLayerType())
517 assert.Equal(t, me.PriorityQueueClassID, response.ReportedME.GetClassID())
518 assert.Equal(t, uint16(0), response.ReportedME.GetEntityID())
519
520 attributes := me.AttributeValueMap{
521 "QueueConfigurationOption": byte(0),
522 "MaximumQueueSize": uint16(0),
523 "AllocatedQueueSize": uint16(0),
524 "DiscardBlockCounterResetInterval": uint16(0),
525 "ThresholdValueForDiscardedBlocksDueToBufferOverflow": uint16(0),
526 "RelatedPort": uint32(16842752),
527 "TrafficSchedulerPointer": uint16(0),
528 "Weight": byte(1),
529 "BackPressureOperation": uint16(0),
530 "BackPressureTime": uint32(0),
531 "BackPressureOccurQueueThreshold": uint16(0),
532 "BackPressureClearQueueThreshold": uint16(0),
533 }
534 for name, value := range attributes {
535 pktValue, err := response.ReportedME.GetAttribute(name)
536 assert.Nil(t, err)
537 assert.Equal(t, pktValue, value)
538 }
539 // Verify string output for message
540 packetString := packet.String()
541 assert.NotZero(t, len(packetString))
542}
543
544func TestMibUploadNextResponseDecodeExtendedOneMe(t *testing.T) {
545 firstMe := "001801150000ffe001123443215678876501010000FFBB011234000000006789"
546 goodMessage := "02862e0b000200000020" + firstMe
547 data, err := stringToPacket(goodMessage)
548 assert.NoError(t, err)
549
550 packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.NoCopy)
551 assert.NotNil(t, packet)
552
553 omciLayer := packet.Layer(LayerTypeOMCI)
554 assert.NotNil(t, omciLayer)
555
556 omciMsg, ok := omciLayer.(*OMCI)
557 assert.True(t, ok)
558 assert.NotNil(t, omciMsg)
559 assert.Equal(t, LayerTypeOMCI, omciMsg.LayerType())
560 assert.Equal(t, LayerTypeOMCI, omciMsg.CanDecode())
561 assert.Equal(t, LayerTypeMibUploadNextResponse, omciMsg.NextLayerType())
562 assert.Equal(t, uint16(0x0286), omciMsg.TransactionID)
563 assert.Equal(t, MibUploadNextResponseType, omciMsg.MessageType)
564 assert.Equal(t, ExtendedIdent, omciMsg.DeviceIdentifier)
565 assert.Equal(t, uint16(2+6+24), omciMsg.Length)
566
567 msgLayer := packet.Layer(LayerTypeMibUploadNextResponse)
568 assert.NotNil(t, msgLayer)
569
570 response, ok2 := msgLayer.(*MibUploadNextResponse)
571 assert.True(t, ok2)
572 assert.NotNil(t, response)
573 assert.Equal(t, LayerTypeMibUploadNextResponse, response.LayerType())
574 assert.Equal(t, LayerTypeMibUploadNextResponse, response.CanDecode())
575 assert.Equal(t, gopacket.LayerTypePayload, response.NextLayerType())
576 assert.Equal(t, me.PriorityQueueClassID, response.ReportedME.GetClassID())
577 assert.Equal(t, uint16(0), response.ReportedME.GetEntityID())
578
579 attributes := me.AttributeValueMap{
580 "QueueConfigurationOption": byte(1),
581 "MaximumQueueSize": uint16(0x1234),
582 "AllocatedQueueSize": uint16(0x4321),
583 "DiscardBlockCounterResetInterval": uint16(0x5678),
584 "ThresholdValueForDiscardedBlocksDueToBufferOverflow": uint16(0x8765),
585 "RelatedPort": uint32(16842752),
586 "TrafficSchedulerPointer": uint16(0xFFBB),
587 "Weight": byte(1),
588 "BackPressureOperation": uint16(0x1234),
589 "BackPressureTime": uint32(0),
590 "BackPressureOccurQueueThreshold": uint16(0x6789),
591 }
592 // 01 1234 4321 5678 8765 01010000 FFBB 01 1234 00000000 6789
593 // 01123443215678876501010000FFBB011234000000006789
594 // 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4
595 for name, value := range attributes {
596 pktValue, err := response.ReportedME.GetAttribute(name)
597 assert.Nil(t, err)
598 assert.Equal(t, value, pktValue)
599 }
600 // Only the first ME
601 assert.Nil(t, response.AdditionalMEs)
602
603 // Verify string output for message
604 packetString := packet.String()
605 assert.NotZero(t, len(packetString))
606}
607
608func TestMibUploadNextResponseDecodeExtendedThreeMe(t *testing.T) {
609 first := "001801150000ffe001123443215678876501010000FFBB011234000000006789"
610 second := "001801150001ffe001123443215678876501010000FFBB011234000000006789"
611 third := "001801150002ffe001123443215678876501010000FFBB011234000000006789"
612 goodMessage := "02862e0b000200000060" + first + second + third
613 data, err := stringToPacket(goodMessage)
614 assert.NoError(t, err)
615
Chip Boling610117d2021-09-09 11:24:34 -0500[diff] [blame]616 packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.NoCopy)
617 assert.NotNil(t, packet)
618
619 omciLayer := packet.Layer(LayerTypeOMCI)
620 assert.NotNil(t, omciLayer)
621
622 omciMsg, ok := omciLayer.(*OMCI)
623 assert.True(t, ok)
624 assert.NotNil(t, omciMsg)
625 assert.Equal(t, LayerTypeOMCI, omciMsg.LayerType())
626 assert.Equal(t, LayerTypeOMCI, omciMsg.CanDecode())
627 assert.Equal(t, LayerTypeMibUploadNextResponse, omciMsg.NextLayerType())
628 assert.Equal(t, uint16(0x0286), omciMsg.TransactionID)
629 assert.Equal(t, MibUploadNextResponseType, omciMsg.MessageType)
630 assert.Equal(t, ExtendedIdent, omciMsg.DeviceIdentifier)
631 assert.Equal(t, uint16(3*(8+24)), omciMsg.Length)
632
633 msgLayer := packet.Layer(LayerTypeMibUploadNextResponse)
634 assert.NotNil(t, msgLayer)
635
636 response, ok2 := msgLayer.(*MibUploadNextResponse)
637 assert.True(t, ok2)
638 assert.NotNil(t, response)
639 assert.Equal(t, LayerTypeMibUploadNextResponse, response.LayerType())
640 assert.Equal(t, LayerTypeMibUploadNextResponse, response.CanDecode())
641 assert.Equal(t, gopacket.LayerTypePayload, response.NextLayerType())
642 assert.Equal(t, me.PriorityQueueClassID, response.ReportedME.GetClassID())
643 assert.Equal(t, uint16(0), response.ReportedME.GetEntityID())
644
645 attributes := me.AttributeValueMap{
646 "QueueConfigurationOption": byte(1),
647 "MaximumQueueSize": uint16(0x1234),
648 "AllocatedQueueSize": uint16(0x4321),
649 "DiscardBlockCounterResetInterval": uint16(0x5678),
650 "ThresholdValueForDiscardedBlocksDueToBufferOverflow": uint16(0x8765),
651 "RelatedPort": uint32(16842752),
652 "TrafficSchedulerPointer": uint16(0xFFBB),
653 "Weight": byte(1),
654 "BackPressureOperation": uint16(0x1234),
655 "BackPressureTime": uint32(0),
656 "BackPressureOccurQueueThreshold": uint16(0x6789),
657 }
658 // 01 1234 4321 5678 8765 01010000 FFBB 01 1234 00000000 6789
659 // 01123443215678876501010000FFBB011234000000006789
660 // 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4
661 for name, value := range attributes {
662 pktValue, err := response.ReportedME.GetAttribute(name)
663 assert.Nil(t, err)
664 assert.Equal(t, value, pktValue)
665 }
666 // Other two are the same, just different managed entity IDs
667
668 assert.Equal(t, 2, len(response.AdditionalMEs))
669 assert.Equal(t, me.PriorityQueueClassID, response.AdditionalMEs[0].GetClassID())
670 assert.Equal(t, uint16(1), response.AdditionalMEs[0].GetEntityID())
671 for name, value := range attributes {
672 pktValue, err := response.AdditionalMEs[0].GetAttribute(name)
673 assert.Nil(t, err)
674 assert.Equal(t, value, pktValue)
675 }
676 assert.Equal(t, me.PriorityQueueClassID, response.AdditionalMEs[1].GetClassID())
677 assert.Equal(t, uint16(2), response.AdditionalMEs[1].GetEntityID())
678 for name, value := range attributes {
679 pktValue, err := response.AdditionalMEs[1].GetAttribute(name)
680 assert.Nil(t, err)
681 assert.Equal(t, value, pktValue)
682 }
683 // Verify string output for message
684 packetString := packet.String()
685 assert.NotZero(t, len(packetString))
686}
687
688func TestMibUploadNextResponseDecodeExtendedMaxLength(t *testing.T) {
689 // Max payload after header length field and not including MIC is 1966 octets
690 maxPayloadLen := MaxExtendedLength - 10 - 4
691
692 // Payload is AttrLen (2) + ME Hdr (6) + attributes which is 30 octets
693 // below. That allows 65 'common' payloads with a remainder of 16 octets
694 // to fill with another ME
695 commonPayloadFmt := "00160115%04xffc001123443215678876501010000FFBB01123487654321"
696 lastPayload := "00080115000078001234432156788765"
697 msgHeader := fmt.Sprintf("02862e0b00020000%04x", maxPayloadLen)
698 numCommon := 65
699
700 goodMessage := msgHeader + fmt.Sprintf(commonPayloadFmt, 0)
701 for instance := 1; instance < numCommon; instance++ {
702 goodMessage += fmt.Sprintf(commonPayloadFmt, instance)
703 }
704 goodMessage += lastPayload
705
706 data, err := stringToPacket(goodMessage)
707 assert.NoError(t, err)
708 assert.Equal(t, MaxExtendedLength-4, len(data))
709
710 packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.NoCopy)
711 assert.NotNil(t, packet)
712
713 omciLayer := packet.Layer(LayerTypeOMCI)
714 assert.NotNil(t, omciLayer)
715
716 omciMsg, ok := omciLayer.(*OMCI)
717 assert.True(t, ok)
718 assert.NotNil(t, omciMsg)
719 assert.Equal(t, LayerTypeOMCI, omciMsg.LayerType())
720 assert.Equal(t, LayerTypeOMCI, omciMsg.CanDecode())
721 assert.Equal(t, LayerTypeMibUploadNextResponse, omciMsg.NextLayerType())
722 assert.Equal(t, uint16(0x0286), omciMsg.TransactionID)
723 assert.Equal(t, MibUploadNextResponseType, omciMsg.MessageType)
724 assert.Equal(t, ExtendedIdent, omciMsg.DeviceIdentifier)
725 assert.Equal(t, uint16(maxPayloadLen), omciMsg.Length)
726
727 msgLayer := packet.Layer(LayerTypeMibUploadNextResponse)
728 assert.NotNil(t, msgLayer)
729
730 response, ok2 := msgLayer.(*MibUploadNextResponse)
731 assert.True(t, ok2)
732 assert.NotNil(t, response)
733 assert.Equal(t, LayerTypeMibUploadNextResponse, response.LayerType())
734 assert.Equal(t, LayerTypeMibUploadNextResponse, response.CanDecode())
735 assert.Equal(t, gopacket.LayerTypePayload, response.NextLayerType())
736 assert.Equal(t, me.PriorityQueueClassID, response.ReportedME.GetClassID())
737 assert.Equal(t, uint16(0), response.ReportedME.GetEntityID())
738
739 attributes := me.AttributeValueMap{
740 "QueueConfigurationOption": byte(1),
741 "MaximumQueueSize": uint16(0x1234),
742 "AllocatedQueueSize": uint16(0x4321),
743 "DiscardBlockCounterResetInterval": uint16(0x5678),
744 "ThresholdValueForDiscardedBlocksDueToBufferOverflow": uint16(0x8765),
745 "RelatedPort": uint32(16842752),
746 "TrafficSchedulerPointer": uint16(0xFFBB),
747 "Weight": byte(1),
748 "BackPressureOperation": uint16(0x1234),
749 "BackPressureTime": uint32(0x87654321),
750 }
751 lastPayloadAttributes := me.AttributeValueMap{
752 "MaximumQueueSize": uint16(0x1234),
753 "AllocatedQueueSize": uint16(0x4321),
754 "DiscardBlockCounterResetInterval": uint16(0x5678),
755 "ThresholdValueForDiscardedBlocksDueToBufferOverflow": uint16(0x8765),
756 }
757 // Check first ME that is stored in same location as in baseline message
758 for name, value := range attributes {
759 pktValue, err := response.ReportedME.GetAttribute(name)
760 assert.Nil(t, err)
761 assert.Equal(t, value, pktValue)
762 }
763 // Check remainder of the package = (numCommon - 1) + trailing me
764 assert.Equal(t, numCommon, len(response.AdditionalMEs))
765 for index, additional := range response.AdditionalMEs {
766 if index == numCommon-1 {
767 break
768 }
769 assert.Equal(t, me.PriorityQueueClassID, additional.GetClassID())
770 assert.Equal(t, uint16(index+1), additional.GetEntityID())
771 for name, value := range attributes {
772 pktValue, err := additional.GetAttribute(name)
773 assert.Nil(t, err)
774 assert.Equal(t, value, pktValue)
775 }
776 }
777 // And check the last one
778 assert.Equal(t, me.PriorityQueueClassID, response.AdditionalMEs[numCommon-1].GetClassID())
779 assert.Equal(t, uint16(0), response.AdditionalMEs[numCommon-1].GetEntityID())
780 for name, value := range lastPayloadAttributes {
781 pktValue, err := response.AdditionalMEs[numCommon-1].GetAttribute(name)
782 assert.Nil(t, err)
783 assert.Equal(t, value, pktValue)
784 }
785 // Verify string output for message
786 packetString := packet.String()
787 assert.NotZero(t, len(packetString))
788}
789
790func TestMibUploadNextResponseSerialize(t *testing.T) {
791 goodMessage := "02862e0a0002000001150000fff0000000000000000000010100000000010002000000030004000500000028"
792
793 omciLayer := &OMCI{
794 TransactionID: 0x0286,
795 MessageType: MibUploadNextResponseType,
796 // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
797 // Length: 0x28, // Optional, defaults to 40 octets
798 }
799 paramData := me.ParamData{
800 EntityID: uint16(0),
801 Attributes: me.AttributeValueMap{
802 "QueueConfigurationOption": byte(0),
803 "MaximumQueueSize": uint16(0),
804 "AllocatedQueueSize": uint16(0),
805 "DiscardBlockCounterResetInterval": uint16(0),
806 "ThresholdValueForDiscardedBlocksDueToBufferOverflow": uint16(0),
807 "RelatedPort": uint32(16842752),
808 "TrafficSchedulerPointer": uint16(0),
809 "Weight": byte(1),
810 "BackPressureOperation": uint16(2),
811 "BackPressureTime": uint32(3),
812 "BackPressureOccurQueueThreshold": uint16(4),
813 "BackPressureClearQueueThreshold": uint16(5),
814 },
815 }
816 reportedME, err := me.NewPriorityQueue(paramData)
817 assert.NotNil(t, err)
818 assert.Equal(t, err.StatusCode(), me.Success)
819
820 request := &MibUploadNextResponse{
821 MeBasePacket: MeBasePacket{
822 EntityClass: me.OnuDataClassID,
823 EntityInstance: uint16(0),
824 },
825 ReportedME: *reportedME,
826 }
827 // Test serialization back to former string
828 var options gopacket.SerializeOptions
829 options.FixLengths = true
830
831 buffer := gopacket.NewSerializeBuffer()
832 omciErr := gopacket.SerializeLayers(buffer, options, omciLayer, request)
833 assert.NoError(t, omciErr)
834
835 outgoingPacket := buffer.Bytes()
836 reconstituted := packetToString(outgoingPacket)
837 assert.Equal(t, strings.ToLower(goodMessage), reconstituted)
838}
839
840func TestMibUploadNextResponseZeroTICSerialize(t *testing.T) {
841 omciLayer := &OMCI{
842 TransactionID: 0x0,
843 MessageType: MibUploadNextResponseType,
844 // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
845 // Length: 0x28, // Optional, defaults to 40 octets
846 }
847 paramData := me.ParamData{
848 EntityID: uint16(0),
849 Attributes: me.AttributeValueMap{
850 "QueueConfigurationOption": byte(0),
851 "MaximumQueueSize": uint16(0),
852 "AllocatedQueueSize": uint16(0),
853 "DiscardBlockCounterResetInterval": uint16(0),
854 "ThresholdValueForDiscardedBlocksDueToBufferOverflow": uint16(0),
855 "RelatedPort": uint32(16842752),
856 "TrafficSchedulerPointer": uint16(0),
857 "Weight": byte(1),
858 "BackPressureOperation": uint16(2),
859 "BackPressureTime": uint32(3),
860 "BackPressureOccurQueueThreshold": uint16(4),
861 "BackPressureClearQueueThreshold": uint16(5),
862 },
863 }
864 reportedME, err := me.NewPriorityQueue(paramData)
865 assert.NotNil(t, err)
866 assert.Equal(t, err.StatusCode(), me.Success)
867
868 request := &MibUploadNextResponse{
869 MeBasePacket: MeBasePacket{
870 EntityClass: me.OnuDataClassID,
871 EntityInstance: uint16(0),
872 },
873 ReportedME: *reportedME,
874 }
875 // Test serialization back to former string
876 var options gopacket.SerializeOptions
877 options.FixLengths = true
878
879 buffer := gopacket.NewSerializeBuffer()
880 omciErr := gopacket.SerializeLayers(buffer, options, omciLayer, request)
881 assert.Error(t, omciErr)
882}
883
884func TestMibUploadNextResponseSerializeExtendedOneMe(t *testing.T) {
885 firstMe := "001801150000ffe001123443215678876501010000FFBB011234000000006789"
886 goodMessage := "02862e0b000200000020" + firstMe
887
888 omciLayer := &OMCI{
889 TransactionID: 0x0286,
890 MessageType: MibUploadNextResponseType,
891 DeviceIdentifier: ExtendedIdent,
892 }
893 paramData := me.ParamData{
894 EntityID: uint16(0),
895 Attributes: me.AttributeValueMap{
896 "QueueConfigurationOption": byte(1),
897 "MaximumQueueSize": uint16(0x1234),
898 "AllocatedQueueSize": uint16(0x4321),
899 "DiscardBlockCounterResetInterval": uint16(0x5678),
900 "ThresholdValueForDiscardedBlocksDueToBufferOverflow": uint16(0x8765),
901 "RelatedPort": uint32(16842752),
902 "TrafficSchedulerPointer": uint16(0xFFBB),
903 "Weight": byte(1),
904 "BackPressureOperation": uint16(0x1234),
905 "BackPressureTime": uint32(0),
906 "BackPressureOccurQueueThreshold": uint16(0x6789),
907 },
908 }
909 reportedME, err := me.NewPriorityQueue(paramData)
910 assert.NotNil(t, err)
911 assert.Equal(t, err.StatusCode(), me.Success)
912
913 request := &MibUploadNextResponse{
914 MeBasePacket: MeBasePacket{
915 EntityClass: me.OnuDataClassID,
916 EntityInstance: uint16(0),
917 Extended: true,
918 },
919 ReportedME: *reportedME,
920 }
921 // Test serialization back to former string
922 var options gopacket.SerializeOptions
923 options.FixLengths = true
924
925 buffer := gopacket.NewSerializeBuffer()
926 omciErr := gopacket.SerializeLayers(buffer, options, omciLayer, request)
927 assert.NoError(t, omciErr)
928
929 outgoingPacket := buffer.Bytes()
930 reconstituted := packetToString(outgoingPacket)
931 assert.Equal(t, strings.ToLower(goodMessage), reconstituted)
932}
933
934func TestMibUploadNextResponseSerializeExtendedTwoMe(t *testing.T) {
935 first := "001801150000ffe001123443215678876501010000FFBB011234000000006789"
936 second := "001801150001ffe001123443215678876501010000FFBB011234000000006789"
937 goodMessage := "02862e0b000200000040" + first + second
938
939 omciLayer := &OMCI{
940 TransactionID: 0x0286,
941 MessageType: MibUploadNextResponseType,
942 DeviceIdentifier: ExtendedIdent,
943 }
944 paramData := me.ParamData{
945 EntityID: uint16(0),
946 Attributes: me.AttributeValueMap{
947 "QueueConfigurationOption": byte(1),
948 "MaximumQueueSize": uint16(0x1234),
949 "AllocatedQueueSize": uint16(0x4321),
950 "DiscardBlockCounterResetInterval": uint16(0x5678),
951 "ThresholdValueForDiscardedBlocksDueToBufferOverflow": uint16(0x8765),
952 "RelatedPort": uint32(16842752),
953 "TrafficSchedulerPointer": uint16(0xFFBB),
954 "Weight": byte(1),
955 "BackPressureOperation": uint16(0x1234),
956 "BackPressureTime": uint32(0),
957 "BackPressureOccurQueueThreshold": uint16(0x6789),
958 },
959 }
960 reportedME, err := me.NewPriorityQueue(paramData)
961 assert.NotNil(t, err)
962 assert.Equal(t, err.StatusCode(), me.Success)
963 additional := make([]me.ManagedEntity, 1)
964
965 for inst := 1; inst < 2; inst++ {
966 paramData.EntityID = uint16(inst)
967 entity, _ := me.NewPriorityQueue(paramData)
968 additional[inst-1] = *entity
969 }
970 request := &MibUploadNextResponse{
971 MeBasePacket: MeBasePacket{
972 EntityClass: me.OnuDataClassID,
973 EntityInstance: uint16(0),
974 Extended: true,
975 },
976 ReportedME: *reportedME,
977 AdditionalMEs: additional,
978 }
979 // Test serialization back to former string
980 var options gopacket.SerializeOptions
981 options.FixLengths = true
982
983 buffer := gopacket.NewSerializeBuffer()
984 omciErr := gopacket.SerializeLayers(buffer, options, omciLayer, request)
985 assert.NoError(t, omciErr)
986
987 outgoingPacket := buffer.Bytes()
988 reconstituted := packetToString(outgoingPacket)
989 assert.Equal(t, strings.ToLower(goodMessage), reconstituted)
990}
991
992func TestMibUploadNextResponseSerializeExtendedThreeMe(t *testing.T) {
993 first := "001801150000ffe001123443215678876501010000FFBB011234000000006789"
994 second := "001801150001ffe001123443215678876501010000FFBB011234000000006789"
995 third := "001801150002ffe001123443215678876501010000FFBB011234000000006789"
996 goodMessage := "02862e0b000200000060" + first + second + third
997
998 omciLayer := &OMCI{
999 TransactionID: 0x0286,
1000 MessageType: MibUploadNextResponseType,
1001 DeviceIdentifier: ExtendedIdent,
1002 }
1003 paramData := me.ParamData{
1004 EntityID: uint16(0),
1005 Attributes: me.AttributeValueMap{
1006 "QueueConfigurationOption": byte(1),
1007 "MaximumQueueSize": uint16(0x1234),
1008 "AllocatedQueueSize": uint16(0x4321),
1009 "DiscardBlockCounterResetInterval": uint16(0x5678),
1010 "ThresholdValueForDiscardedBlocksDueToBufferOverflow": uint16(0x8765),
1011 "RelatedPort": uint32(16842752),
1012 "TrafficSchedulerPointer": uint16(0xFFBB),
1013 "Weight": byte(1),
1014 "BackPressureOperation": uint16(0x1234),
1015 "BackPressureTime": uint32(0),
1016 "BackPressureOccurQueueThreshold": uint16(0x6789),
1017 },
1018 }
1019 reportedME, err := me.NewPriorityQueue(paramData)
1020 assert.NotNil(t, err)
1021 assert.Equal(t, err.StatusCode(), me.Success)
1022 additional := make([]me.ManagedEntity, 2)
1023
1024 for inst := 1; inst < 3; inst++ {
1025 paramData.EntityID = uint16(inst)
1026 entity, _ := me.NewPriorityQueue(paramData)
1027 additional[inst-1] = *entity
1028 }
1029 request := &MibUploadNextResponse{
1030 MeBasePacket: MeBasePacket{
1031 EntityClass: me.OnuDataClassID,
1032 EntityInstance: uint16(0),
1033 Extended: true,
1034 },
1035 ReportedME: *reportedME,
1036 AdditionalMEs: additional,
1037 }
1038 // Test serialization back to former string
1039 var options gopacket.SerializeOptions
1040 options.FixLengths = true
1041
1042 buffer := gopacket.NewSerializeBuffer()
1043 omciErr := gopacket.SerializeLayers(buffer, options, omciLayer, request)
1044 assert.NoError(t, omciErr)
1045
1046 outgoingPacket := buffer.Bytes()
1047 reconstituted := packetToString(outgoingPacket)
1048 assert.Equal(t, strings.ToLower(goodMessage), reconstituted)
1049}
1050
1051func TestMibUploadNextResponseSerializeExtendedMaxFrame(t *testing.T) {
1052 // Max payload after header length field and not including MIC is 1966 octets
1053 maxPayloadLen := MaxExtendedLength - 10 - 4
1054
1055 // Payload is AttrLen (2) + ME Hdr (6) + attributes which is 30 octets
1056 // below. That allows 65 'common' payloads with a remainder of 16 octets
1057 // to fill with another ME
1058 commonPayloadFmt := "00160115%04xffc001123443215678876501010000FFBB01123487654321"
1059 lastPayload := "00080115000078001234432156788765"
1060 msgHeader := fmt.Sprintf("02862e0b00020000%04x", maxPayloadLen)
1061 numCommon := 65
1062
1063 goodMessage := msgHeader + fmt.Sprintf(commonPayloadFmt, 0)
1064 for instance := 1; instance < numCommon; instance++ {
1065 goodMessage += fmt.Sprintf(commonPayloadFmt, instance)
1066 }
1067 goodMessage += lastPayload
1068
1069 omciLayer := &OMCI{
1070 TransactionID: 0x0286,
1071 MessageType: MibUploadNextResponseType,
1072 DeviceIdentifier: ExtendedIdent,
1073 }
1074 paramData := me.ParamData{
1075 EntityID: uint16(0),
1076 Attributes: me.AttributeValueMap{
1077 "QueueConfigurationOption": byte(1),
1078 "MaximumQueueSize": uint16(0x1234),
1079 "AllocatedQueueSize": uint16(0x4321),
1080 "DiscardBlockCounterResetInterval": uint16(0x5678),
1081 "ThresholdValueForDiscardedBlocksDueToBufferOverflow": uint16(0x8765),
1082 "RelatedPort": uint32(16842752),
1083 "TrafficSchedulerPointer": uint16(0xFFBB),
1084 "Weight": byte(1),
1085 "BackPressureOperation": uint16(0x1234),
1086 "BackPressureTime": uint32(0x87654321),
1087 },
1088 }
1089 reportedME, err := me.NewPriorityQueue(paramData)
1090 assert.NotNil(t, err)
1091 assert.Equal(t, err.StatusCode(), me.Success)
1092 request := &MibUploadNextResponse{
1093 MeBasePacket: MeBasePacket{
1094 EntityClass: me.OnuDataClassID,
1095 EntityInstance: uint16(0),
1096 Extended: true,
1097 },
1098 ReportedME: *reportedME,
1099 AdditionalMEs: make([]me.ManagedEntity, numCommon),
1100 }
1101 for instance := 0; instance < numCommon-1; instance++ {
1102 paramData.EntityID = uint16(instance + 1)
1103 reportedME, err = me.NewPriorityQueue(paramData)
1104 assert.NotNil(t, err)
1105 assert.Equal(t, err.StatusCode(), me.Success)
1106 request.AdditionalMEs[instance] = *reportedME
1107 }
1108 lastMeParams := me.ParamData{
1109 EntityID: uint16(0),
1110 Attributes: me.AttributeValueMap{
1111 "MaximumQueueSize": uint16(0x1234),
1112 "AllocatedQueueSize": uint16(0x4321),
1113 "DiscardBlockCounterResetInterval": uint16(0x5678),
1114 "ThresholdValueForDiscardedBlocksDueToBufferOverflow": uint16(0x8765),
1115 },
1116 }
1117 // And the last one to fully fill out the maximum sized frame
1118 reportedME, err = me.NewPriorityQueue(lastMeParams)
1119 assert.NotNil(t, err)
1120 assert.Equal(t, err.StatusCode(), me.Success)
1121 request.AdditionalMEs[numCommon-1] = *reportedME
1122
1123 // Test serialization back to former string
1124 var options gopacket.SerializeOptions
1125 options.FixLengths = true
1126
1127 buffer := gopacket.NewSerializeBuffer()
1128 omciErr := gopacket.SerializeLayers(buffer, options, omciLayer, request)
1129 assert.NoError(t, omciErr)
1130
1131 outgoingPacket := buffer.Bytes()
1132 reconstituted := packetToString(outgoingPacket)
1133 assert.Equal(t, strings.ToLower(goodMessage), reconstituted)
1134}
1135
1136func TestMibUploadNextResponseSerializeExtendedMaxFramePlusOneByteTooMany(t *testing.T) {
1137 // Identical to last test but last ME has one extra octet
1138 numCommon := 65
1139 omciLayer := &OMCI{
1140 TransactionID: 0x0286,
1141 MessageType: MibUploadNextResponseType,
1142 DeviceIdentifier: ExtendedIdent,
1143 }
1144 paramData := me.ParamData{
1145 EntityID: uint16(0),
1146 Attributes: me.AttributeValueMap{
1147 "QueueConfigurationOption": byte(1),
1148 "MaximumQueueSize": uint16(0x1234),
1149 "AllocatedQueueSize": uint16(0x4321),
1150 "DiscardBlockCounterResetInterval": uint16(0x5678),
1151 "ThresholdValueForDiscardedBlocksDueToBufferOverflow": uint16(0x8765),
1152 "RelatedPort": uint32(16842752),
1153 "TrafficSchedulerPointer": uint16(0xFFBB),
1154 "Weight": byte(1),
1155 "BackPressureOperation": uint16(0x1234),
1156 "BackPressureTime": uint32(0x87654321),
1157 },
1158 }
1159 reportedME, err := me.NewPriorityQueue(paramData)
1160 assert.NotNil(t, err)
1161 assert.Equal(t, err.StatusCode(), me.Success)
1162 request := &MibUploadNextResponse{
1163 MeBasePacket: MeBasePacket{
1164 EntityClass: me.OnuDataClassID,
1165 EntityInstance: uint16(0),
1166 Extended: true,
1167 },
1168 ReportedME: *reportedME,
1169 AdditionalMEs: make([]me.ManagedEntity, numCommon),
1170 }
1171 for instance := 0; instance < numCommon-1; instance++ {
1172 paramData.EntityID = uint16(instance + 1)
1173 reportedME, err = me.NewPriorityQueue(paramData)
1174 assert.NotNil(t, err)
1175 assert.Equal(t, err.StatusCode(), me.Success)
1176 request.AdditionalMEs[instance] = *reportedME
1177 }
1178 lastMeParams := me.ParamData{
1179 EntityID: uint16(0),
1180 Attributes: me.AttributeValueMap{
1181 "QueueConfigurationOption": byte(1), // This is the extra byte
1182 "MaximumQueueSize": uint16(0x1234),
1183 "AllocatedQueueSize": uint16(0x4321),
1184 "DiscardBlockCounterResetInterval": uint16(0x5678),
1185 "ThresholdValueForDiscardedBlocksDueToBufferOverflow": uint16(0x8765),
1186 },
1187 }
1188 // And the last one to fully fill out the maximum sized frame
1189 reportedME, err = me.NewPriorityQueue(lastMeParams)
1190 assert.NotNil(t, err)
1191 assert.Equal(t, err.StatusCode(), me.Success)
1192 request.AdditionalMEs[numCommon-1] = *reportedME
1193
1194 // Test serialization back to former string
1195 var options gopacket.SerializeOptions
1196 options.FixLengths = true
1197
1198 buffer := gopacket.NewSerializeBuffer()
1199 omciErr := gopacket.SerializeLayers(buffer, options, omciLayer, request)
1200 assert.Error(t, omciErr)
1201}
1202
1203func TestMibUploadNextResponseBadCommandNumberDecode(t *testing.T) {
1204 // Test of a MIB Upload next Response that results when an invalid command number.
1205 // Note that if all attributes of a managed entity do not fit within one MIB
1206 // upload next response message, the attributes will be split over several
1207 // messages. The OLT can use the information in the attribute mask to determine
1208 // which attribute values are reported in which MIB upload next response message.
1209 //TODO: Implement
1210}
1211
1212func TestMibUploadNextResponseBadCommandNumberSerialize(t *testing.T) {
1213 // Test of a MIB Upload next Response that results when an invalid command number
1214 // is requested.
1215 //TODO: Implement
1216}
1217
1218func TestMibUploadNextSequence(t *testing.T) {
1219 mibUploadNextSequence := [...]string{
1220 "00032e0a00020000000200008000000000000000000000000000000000000000000000000000000000000028",
1221 "00042e0a0002000000050101f0002f2f05202020202020202020202020202020202020202000000000000028",
1222 "00052e0a00020000000501010f80202020202020202020202020202020202020202000000000000000000028",
1223 "00062e0a0002000000050104f000303001202020202020202020202020202020202020202000000000000028",
1224 "00072e0a00020000000501040f80202020202020202020202020202020202020202000000000000000000028",
1225 "00082e0a0002000000050180f000f8f801202020202020202020202020202020202020202000000000000028",
1226 "00092e0a00020000000501800f80202020202020202020202020202020202020202000000000000000000028",
1227 "000a2e0a0002000000060101f0002f054252434d12345678000000000000000000000000000c000000000028",
1228 "000b2e0a00020000000601010f004252434d0000000000000000000000000000000000000000000000000028",
1229 "000c2e0a000200000006010100f8202020202020202020202020202020202020202000000000000000000028",
1230 "000d2e0a00020000000601010004000000000000000000000000000000000000000000000000000000000028",
1231 "000e2e0a0002000000060104f00030014252434d12345678000000000000000000000000000c000000000028",
1232 "000f2e0a00020000000601040f004252434d0000000000000000000000000000000000000000000000000028",
1233 "00102e0a000200000006010400f8202020202020202020202020202020202020202000000800000000000028",
1234 "00112e0a00020000000601040004000000000000000000000000000000000000000000000000000000000028",
1235 "00122e0a0002000000060180f000f8014252434d12345678000000000000000000000000000c000000000028",
1236 "00132e0a00020000000601800f004252434d0000000000000000000000000000000000000000000000000028",
1237 "00142e0a000200000006018000f8202020202020202020202020202020202020202000084040000000000028",
1238 "00152e0a00020000000601800004000000000000000000000000000000000000000000000000000000000028",
1239 "00162e0a0002000000070000f0003530323247574f3236363230303301010100000000000000000000000028",
1240 "00172e0a0002000000070001f0003530323247574f3236363230303300000100000000000000000000000028",
1241 "00182e0a0002000000830000c000202020202020202020202020202020202020202020202020000000000028",
1242 "00192e0a00020000008300002000202020202020202020202020202000000000000000000000000000000028",
1243 "001a2e0a00020000008300001000000000000000000000000000000000000000000000000000000000000028",
1244 "001b2e0a0002000000850000ffe0000000000000000000000000000000000000000000000000000000000028",
1245 "001c2e0a0002000000860001c00000001018aaaa000000000000000000000000000000000000000000000028",
1246 "001d2e0a00020000008600012000000000000000000000000000000000000000000000000000000000000028",
1247 "001e2e0a00020000008600011f80000000000000000000000000000000000000000000000000000000000028",
1248 "001f2e0a00020000008600010078000000000000000000000000000000000000000000000000000000000028",
1249 "00202e0a00020000008600010004000000000000000000000000000000000000000000000000000000000028",
1250 "00212e0a00020000008600010002000000000000000000000000000000000000000000000000000000000028",
1251 "00222e0a0002000001000000e0004252434d00000000000000000000000000004252434d1234567800000028",
1252 "00232e0a00020000010000001f80000000000000000000000000000000000000000000000000000000000028",
1253 "00242e0a00020000010000000040000000000000000000000000000000000000000000000000000000000028",
1254 "00252e0a00020000010000000038000000000000000000000000000003000000000000000000000000000028",
1255 "00262e0a0002000001010000f80042564d344b3030425241303931352d3030383300b3000001010000000028",
1256 "00272e0a000200000101000007f8000000010020027c85630016000030000000000000000000000000000028",
1257 "00282e0a0002000001068000e00000ff01010000000000000000000000000000000000000000000000000028",
1258 "00292e0a0002000001068001e00000ff01010000000000000000000000000000000000000000000000000028",
1259 "002a2e0a0002000001068002e00000ff01010000000000000000000000000000000000000000000000000028",
1260 "002b2e0a0002000001068003e00000ff01010000000000000000000000000000000000000000000000000028",
1261 "002c2e0a0002000001068004e00000ff01010000000000000000000000000000000000000000000000000028",
1262 "002d2e0a0002000001068005e00000ff01010000000000000000000000000000000000000000000000000028",
1263 "002e2e0a0002000001068006e00000ff01010000000000000000000000000000000000000000000000000028",
1264 "002f2e0a0002000001068007e00000ff01010000000000000000000000000000000000000000000000000028",
1265 "00302e0a0002000001078001ffff01000800300000050900000000ffff000000008181000000000000000028",
1266 "00312e0a0002000001080401f000000000000401000000000000000000000000000000000000000000000028",
1267 "00322e0a0002000001150401fff0000080008000000000040100000000010000000000000000000000000028",
1268 "00332e0a0002000001150401000f0200020002000200ffff0900000000000000000000000000000000000028",
1269 "00342e0a0002000001150402fff0000080008000000000040100010000010000000000000000000000000028",
1270 "00352e0a0002000001150402000f0200020002000200ffff0900000000000000000000000000000000000028",
1271 "00362e0a0002000001150403fff0000080008000000000040100020000010000000000000000000000000028",
1272 "00372e0a0002000001150403000f0200020002000200ffff0900000000000000000000000000000000000028",
1273 "00382e0a0002000001150404fff0000080008000000000040100030000010000000000000000000000000028",
1274 "00392e0a0002000001150404000f0200020002000200ffff0900000000000000000000000000000000000028",
1275 "003a2e0a0002000001150405fff0000080008000000000040100040000010000000000000000000000000028",
1276 "003b2e0a0002000001150405000f0200020002000200ffff0900000000000000000000000000000000000028",
1277 "003c2e0a0002000001150406fff0000080008000000000040100050000010000000000000000000000000028",
1278 "003d2e0a0002000001150406000f0200020002000200ffff0900000000000000000000000000000000000028",
1279 "003e2e0a0002000001150407fff0000080008000000000040100060000010000000000000000000000000028",
1280 "003f2e0a0002000001150407000f0200020002000200ffff0900000000000000000000000000000000000028",
1281 "00402e0a0002000001150408fff0000080008000000000040100070000010000000000000000000000000028",
1282 "00412e0a0002000001150408000f0200020002000200ffff0900000000000000000000000000000000000028",
1283 "00422e0a0002000001158000fff0000100010000000000800000000000010000000000000000000000000028",
1284 "00432e0a0002000001158000000f0200020002000200ffff0900000000000000000000000000000000000028",
1285 "00442e0a0002000001158001fff0000100010000000000800000010000010000000000000000000000000028",
1286 "00452e0a0002000001158001000f0200020002000200ffff0900000000000000000000000000000000000028",
1287 "00462e0a0002000001158002fff0000100010000000000800000020000010000000000000000000000000028",
1288 "00472e0a0002000001158002000f0200020002000200ffff0900000000000000000000000000000000000028",
1289 "00482e0a0002000001158003fff0000100010000000000800000030000010000000000000000000000000028",
1290 "00492e0a0002000001158003000f0200020002000200ffff0900000000000000000000000000000000000028",
1291 "004a2e0a0002000001158004fff0000100010000000000800000040000010000000000000000000000000028",
1292 "004b2e0a0002000001158004000f0200020002000200ffff0900000000000000000000000000000000000028",
1293 "004c2e0a0002000001158005fff0000100010000000000800000050000010000000000000000000000000028",
1294 "004d2e0a0002000001158005000f0200020002000200ffff0900000000000000000000000000000000000028",
1295 "004e2e0a0002000001158006fff0000100010000000000800000060000010000000000000000000000000028",
1296 "004f2e0a0002000001158006000f0200020002000200ffff0900000000000000000000000000000000000028",
1297 "00502e0a0002000001158007fff0000100010000000000800000070000010000000000000000000000000028",
1298 "00512e0a0002000001158007000f0200020002000200ffff0900000000000000000000000000000000000028",
1299 "00522e0a0002000001158008fff0000100010000000000800100000000010000000000000000000000000028",
1300 "00532e0a0002000001158008000f0200020002000200ffff0900000000000000000000000000000000000028",
1301 "00542e0a0002000001158009fff0000100010000000000800100010000010000000000000000000000000028",
1302 "00552e0a0002000001158009000f0200020002000200ffff0900000000000000000000000000000000000028",
1303 "00562e0a000200000115800afff0000100010000000000800100020000010000000000000000000000000028",
1304 "00572e0a000200000115800a000f0200020002000200ffff0900000000000000000000000000000000000028",
1305 "00582e0a000200000115800bfff0000100010000000000800100030000010000000000000000000000000028",
1306 "00592e0a000200000115800b000f0200020002000200ffff0900000000000000000000000000000000000028",
1307 "005a2e0a000200000115800cfff0000100010000000000800100040000010000000000000000000000000028",
1308 "005b2e0a000200000115800c000f0200020002000200ffff0900000000000000000000000000000000000028",
1309 "005c2e0a000200000115800dfff0000100010000000000800100050000010000000000000000000000000028",
1310 "005d2e0a000200000115800d000f0200020002000200ffff0900000000000000000000000000000000000028",
1311 "005e2e0a000200000115800efff0000100010000000000800100060000010000000000000000000000000028",
1312 "005f2e0a000200000115800e000f0200020002000200ffff0900000000000000000000000000000000000028",
1313 "00602e0a000200000115800ffff0000100010000000000800100070000010000000000000000000000000028",
1314 "00612e0a000200000115800f000f0200020002000200ffff0900000000000000000000000000000000000028",
1315 "00622e0a0002000001158010fff0000100010000000000800200000000010000000000000000000000000028",
1316 "00632e0a0002000001158010000f0200020002000200ffff0900000000000000000000000000000000000028",
1317 "00642e0a0002000001158011fff0000100010000000000800200010000010000000000000000000000000028",
1318 "00652e0a0002000001158011000f0200020002000200ffff0900000000000000000000000000000000000028",
1319 "00662e0a0002000001158012fff0000100010000000000800200020000010000000000000000000000000028",
1320 "00672e0a0002000001158012000f0200020002000200ffff0900000000000000000000000000000000000028",
1321 "00682e0a0002000001158013fff0000100010000000000800200030000010000000000000000000000000028",
1322 "00692e0a0002000001158013000f0200020002000200ffff0900000000000000000000000000000000000028",
1323 "006a2e0a0002000001158014fff0000100010000000000800200040000010000000000000000000000000028",
1324 "006b2e0a0002000001158014000f0200020002000200ffff0900000000000000000000000000000000000028",
1325 "006c2e0a0002000001158015fff0000100010000000000800200050000010000000000000000000000000028",
1326 "006d2e0a0002000001158015000f0200020002000200ffff0900000000000000000000000000000000000028",
1327 "006e2e0a0002000001158016fff0000100010000000000800200060000010000000000000000000000000028",
1328 "006f2e0a0002000001158016000f0200020002000200ffff0900000000000000000000000000000000000028",
1329 "00702e0a0002000001158017fff0000100010000000000800200070000010000000000000000000000000028",
1330 "00712e0a0002000001158017000f0200020002000200ffff0900000000000000000000000000000000000028",
1331 "00722e0a0002000001158018fff0000100010000000000800300000000010000000000000000000000000028",
1332 "00732e0a0002000001158018000f0200020002000200ffff0900000000000000000000000000000000000028",
1333 "00742e0a0002000001158019fff0000100010000000000800300010000010000000000000000000000000028",
1334 "00752e0a0002000001158019000f0200020002000200ffff0900000000000000000000000000000000000028",
1335 "00762e0a000200000115801afff0000100010000000000800300020000010000000000000000000000000028",
1336 "00772e0a000200000115801a000f0200020002000200ffff0900000000000000000000000000000000000028",
1337 "00782e0a000200000115801bfff0000100010000000000800300030000010000000000000000000000000028",
1338 "00792e0a000200000115801b000f0200020002000200ffff0900000000000000000000000000000000000028",
1339 "007a2e0a000200000115801cfff0000100010000000000800300040000010000000000000000000000000028",
1340 "007b2e0a000200000115801c000f0200020002000200ffff0900000000000000000000000000000000000028",
1341 "007c2e0a000200000115801dfff0000100010000000000800300050000010000000000000000000000000028",
1342 "007d2e0a000200000115801d000f0200020002000200ffff0900000000000000000000000000000000000028",
1343 "007e2e0a000200000115801efff0000100010000000000800300060000010000000000000000000000000028",
1344 "007f2e0a000200000115801e000f0200020002000200ffff0900000000000000000000000000000000000028",
1345 "00802e0a000200000115801ffff0000100010000000000800300070000010000000000000000000000000028",
1346 "00812e0a000200000115801f000f0200020002000200ffff0900000000000000000000000000000000000028",
1347 "00822e0a0002000001158020fff0000100010000000000800400000000010000000000000000000000000028",
1348 "00832e0a0002000001158020000f0200020002000200ffff0900000000000000000000000000000000000028",
1349 "00842e0a0002000001158021fff0000100010000000000800400010000010000000000000000000000000028",
1350 "00852e0a0002000001158021000f0200020002000200ffff0900000000000000000000000000000000000028",
1351 "00862e0a0002000001158022fff0000100010000000000800400020000010000000000000000000000000028",
1352 "00872e0a0002000001158022000f0200020002000200ffff0900000000000000000000000000000000000028",
1353 "00882e0a0002000001158023fff0000100010000000000800400030000010000000000000000000000000028",
1354 "00892e0a0002000001158023000f0200020002000200ffff0900000000000000000000000000000000000028",
1355 "008a2e0a0002000001158024fff0000100010000000000800400040000010000000000000000000000000028",
1356 "008b2e0a0002000001158024000f0200020002000200ffff0900000000000000000000000000000000000028",
1357 "008c2e0a0002000001158025fff0000100010000000000800400050000010000000000000000000000000028",
1358 "008d2e0a0002000001158025000f0200020002000200ffff0900000000000000000000000000000000000028",
1359 "008e2e0a0002000001158026fff0000100010000000000800400060000010000000000000000000000000028",
1360 "008f2e0a0002000001158026000f0200020002000200ffff0900000000000000000000000000000000000028",
1361 "00902e0a0002000001158027fff0000100010000000000800400070000010000000000000000000000000028",
1362 "00912e0a0002000001158027000f0200020002000200ffff0900000000000000000000000000000000000028",
1363 "00922e0a0002000001158028fff0000100010000000000800500000000010000000000000000000000000028",
1364 "00932e0a0002000001158028000f0200020002000200ffff0900000000000000000000000000000000000028",
1365 "00942e0a0002000001158029fff0000100010000000000800500010000010000000000000000000000000028",
1366 "00952e0a0002000001158029000f0200020002000200ffff0900000000000000000000000000000000000028",
1367 "00962e0a000200000115802afff0000100010000000000800500020000010000000000000000000000000028",
1368 "00972e0a000200000115802a000f0200020002000200ffff0900000000000000000000000000000000000028",
1369 "00982e0a000200000115802bfff0000100010000000000800500030000010000000000000000000000000028",
1370 "00992e0a000200000115802b000f0200020002000200ffff0900000000000000000000000000000000000028",
1371 "009a2e0a000200000115802cfff0000100010000000000800500040000010000000000000000000000000028",
1372 "009b2e0a000200000115802c000f0200020002000200ffff0900000000000000000000000000000000000028",
1373 "009c2e0a000200000115802dfff0000100010000000000800500050000010000000000000000000000000028",
1374 "009d2e0a000200000115802d000f0200020002000200ffff0900000000000000000000000000000000000028",
1375 "009e2e0a000200000115802efff0000100010000000000800500060000010000000000000000000000000028",
1376 "009f2e0a000200000115802e000f0200020002000200ffff0900000000000000000000000000000000000028",
1377 "00a02e0a000200000115802ffff0000100010000000000800500070000010000000000000000000000000028",
1378 "00a12e0a000200000115802f000f0200020002000200ffff0900000000000000000000000000000000000028",
1379 "00a22e0a0002000001158030fff0000100010000000000800600000000010000000000000000000000000028",
1380 "00a32e0a0002000001158030000f0200020002000200ffff0900000000000000000000000000000000000028",
1381 "00a42e0a0002000001158031fff0000100010000000000800600010000010000000000000000000000000028",
1382 "00a52e0a0002000001158031000f0200020002000200ffff0900000000000000000000000000000000000028",
1383 "00a62e0a0002000001158032fff0000100010000000000800600020000010000000000000000000000000028",
1384 "00a72e0a0002000001158032000f0200020002000200ffff0900000000000000000000000000000000000028",
1385 "00a82e0a0002000001158033fff0000100010000000000800600030000010000000000000000000000000028",
1386 "00a92e0a0002000001158033000f0200020002000200ffff0900000000000000000000000000000000000028",
1387 "00aa2e0a0002000001158034fff0000100010000000000800600040000010000000000000000000000000028",
1388 "00ab2e0a0002000001158034000f0200020002000200ffff0900000000000000000000000000000000000028",
1389 "00ac2e0a0002000001158035fff0000100010000000000800600050000010000000000000000000000000028",
1390 "00ad2e0a0002000001158035000f0200020002000200ffff0900000000000000000000000000000000000028",
1391 "00ae2e0a0002000001158036fff0000100010000000000800600060000010000000000000000000000000028",
1392 "00af2e0a0002000001158036000f0200020002000200ffff0900000000000000000000000000000000000028",
1393 "00b02e0a0002000001158037fff0000100010000000000800600070000010000000000000000000000000028",
1394 "00b12e0a0002000001158037000f0200020002000200ffff0900000000000000000000000000000000000028",
1395 "00b22e0a0002000001158038fff0000100010000000000800700000000010000000000000000000000000028",
1396 "00b32e0a0002000001158038000f0200020002000200ffff0900000000000000000000000000000000000028",
1397 "00b42e0a0002000001158039fff0000100010000000000800700010000010000000000000000000000000028",
1398 "00b52e0a0002000001158039000f0200020002000200ffff0900000000000000000000000000000000000028",
1399 "00b62e0a000200000115803afff0000100010000000000800700020000010000000000000000000000000028",
1400 "00b72e0a000200000115803a000f0200020002000200ffff0900000000000000000000000000000000000028",
1401 "00b82e0a000200000115803bfff0000100010000000000800700030000010000000000000000000000000028",
1402 "00b92e0a000200000115803b000f0200020002000200ffff0900000000000000000000000000000000000028",
1403 "00ba2e0a000200000115803cfff0000100010000000000800700040000010000000000000000000000000028",
1404 "00bb2e0a000200000115803c000f0200020002000200ffff0900000000000000000000000000000000000028",
1405 "00bc2e0a000200000115803dfff0000100010000000000800700050000010000000000000000000000000028",
1406 "00bd2e0a000200000115803d000f0200020002000200ffff0900000000000000000000000000000000000028",
1407 "00be2e0a000200000115803efff0000100010000000000800700060000010000000000000000000000000028",
1408 "00bf2e0a000200000115803e000f0200020002000200ffff0900000000000000000000000000000000000028",
1409 "00c02e0a000200000115803ffff0000100010000000000800700070000010000000000000000000000000028",
1410 "00c12e0a000200000115803f000f0200020002000200ffff0900000000000000000000000000000000000028",
1411 "00c22e0a0002000001168000f000800000000200000000000000000000000000000000000000000000000028",
1412 "00c32e0a0002000001168001f000800000000200000000000000000000000000000000000000000000000028",
1413 "00c42e0a0002000001168002f000800000000200000000000000000000000000000000000000000000000028",
1414 "00c52e0a0002000001168003f000800000000200000000000000000000000000000000000000000000000028",
1415 "00c62e0a0002000001168004f000800000000200000000000000000000000000000000000000000000000028",
1416 "00c72e0a0002000001168005f000800000000200000000000000000000000000000000000000000000000028",
1417 "00c82e0a0002000001168006f000800000000200000000000000000000000000000000000000000000000028",
1418 "00c92e0a0002000001168007f000800000000200000000000000000000000000000000000000000000000028",
1419 "00ca2e0a0002000001168008f000800100000200000000000000000000000000000000000000000000000028",
1420 "00cb2e0a0002000001168009f000800100000200000000000000000000000000000000000000000000000028",
1421 "00cc2e0a000200000116800af000800100000200000000000000000000000000000000000000000000000028",
1422 "00cd2e0a000200000116800bf000800100000200000000000000000000000000000000000000000000000028",
1423 "00ce2e0a000200000116800cf000800100000200000000000000000000000000000000000000000000000028",
1424 "00cf2e0a000200000116800df000800100000200000000000000000000000000000000000000000000000028",
1425 "00d02e0a000200000116800ef000800100000200000000000000000000000000000000000000000000000028",
1426 "00d12e0a000200000116800ff000800100000200000000000000000000000000000000000000000000000028",
1427 "00d22e0a0002000001168010f000800200000200000000000000000000000000000000000000000000000028",
1428 "00d32e0a0002000001168011f000800200000200000000000000000000000000000000000000000000000028",
1429 "00d42e0a0002000001168012f000800200000200000000000000000000000000000000000000000000000028",
1430 "00d52e0a0002000001168013f000800200000200000000000000000000000000000000000000000000000028",
1431 "00d62e0a0002000001168014f000800200000200000000000000000000000000000000000000000000000028",
1432 "00d72e0a0002000001168015f000800200000200000000000000000000000000000000000000000000000028",
1433 "00d82e0a0002000001168016f000800200000200000000000000000000000000000000000000000000000028",
1434 "00d92e0a0002000001168017f000800200000200000000000000000000000000000000000000000000000028",
1435 "00da2e0a0002000001168018f000800300000200000000000000000000000000000000000000000000000028",
1436 "00db2e0a0002000001168019f000800300000200000000000000000000000000000000000000000000000028",
1437 "00dc2e0a000200000116801af000800300000200000000000000000000000000000000000000000000000028",
1438 "00dd2e0a000200000116801bf000800300000200000000000000000000000000000000000000000000000028",
1439 "00de2e0a000200000116801cf000800300000200000000000000000000000000000000000000000000000028",
1440 "00df2e0a000200000116801df000800300000200000000000000000000000000000000000000000000000028",
1441 "00e02e0a000200000116801ef000800300000200000000000000000000000000000000000000000000000028",
1442 "00e12e0a000200000116801ff000800300000200000000000000000000000000000000000000000000000028",
1443 "00e22e0a0002000001168020f000800400000200000000000000000000000000000000000000000000000028",
1444 "00e32e0a0002000001168021f000800400000200000000000000000000000000000000000000000000000028",
1445 "00e42e0a0002000001168022f000800400000200000000000000000000000000000000000000000000000028",
1446 "00e52e0a0002000001168023f000800400000200000000000000000000000000000000000000000000000028",
1447 "00e62e0a0002000001168024f000800400000200000000000000000000000000000000000000000000000028",
1448 "00e72e0a0002000001168025f000800400000200000000000000000000000000000000000000000000000028",
1449 "00e82e0a0002000001168026f000800400000200000000000000000000000000000000000000000000000028",
1450 "00e92e0a0002000001168027f000800400000200000000000000000000000000000000000000000000000028",
1451 "00ea2e0a0002000001168028f000800500000200000000000000000000000000000000000000000000000028",
1452 "00eb2e0a0002000001168029f000800500000200000000000000000000000000000000000000000000000028",
1453 "00ec2e0a000200000116802af000800500000200000000000000000000000000000000000000000000000028",
1454 "00ed2e0a000200000116802bf000800500000200000000000000000000000000000000000000000000000028",
1455 "00ee2e0a000200000116802cf000800500000200000000000000000000000000000000000000000000000028",
1456 "00ef2e0a000200000116802df000800500000200000000000000000000000000000000000000000000000028",
1457 "00f02e0a000200000116802ef000800500000200000000000000000000000000000000000000000000000028",
1458 "00f12e0a000200000116802ff000800500000200000000000000000000000000000000000000000000000028",
1459 "00f22e0a0002000001168030f000800600000200000000000000000000000000000000000000000000000028",
1460 "00f32e0a0002000001168031f000800600000200000000000000000000000000000000000000000000000028",
1461 "00f42e0a0002000001168032f000800600000200000000000000000000000000000000000000000000000028",
1462 "00f52e0a0002000001168033f000800600000200000000000000000000000000000000000000000000000028",
1463 "00f62e0a0002000001168034f000800600000200000000000000000000000000000000000000000000000028",
1464 "00f72e0a0002000001168035f000800600000200000000000000000000000000000000000000000000000028",
1465 "00f82e0a0002000001168036f000800600000200000000000000000000000000000000000000000000000028",
1466 "00f92e0a0002000001168037f000800600000200000000000000000000000000000000000000000000000028",
1467 "00fa2e0a0002000001168038f000800700000200000000000000000000000000000000000000000000000028",
1468 "00fb2e0a0002000001168039f000800700000200000000000000000000000000000000000000000000000028",
1469 "00fc2e0a000200000116803af000800700000200000000000000000000000000000000000000000000000028",
1470 "00fd2e0a000200000116803bf000800700000200000000000000000000000000000000000000000000000028",
1471 "00fe2e0a000200000116803cf000800700000200000000000000000000000000000000000000000000000028",
1472 "00ff2e0a000200000116803df000800700000200000000000000000000000000000000000000000000000028",
1473 "01002e0a000200000116803ef000800700000200000000000000000000000000000000000000000000000028",
1474 "01012e0a000200000116803ff000800700000200000000000000000000000000000000000000000000000028",
1475 "01022e0a0002000001490401c000000000000000000000000000000000000000000000000000000000000028",
1476 "01032e0a00020000014904012000000000000000000000000000000000000000000000000000000000000028",
1477 "01042e0a00020000014904011800ffffffff0000000000000000000000000000000000000000000000000028",
1478 }
1479 firstTid := uint16(3)
1480
1481 for _, packetString := range mibUploadNextSequence {
1482 data, err := stringToPacket(packetString)
1483 assert.NoError(t, err)
1484
1485 packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.NoCopy)
1486 assert.NotNil(t, packet)
1487
1488 omciLayer := packet.Layer(LayerTypeOMCI)
1489 assert.NotNil(t, omciLayer)
1490
1491 omciMsg, ok := omciLayer.(*OMCI)
1492 assert.True(t, ok)
1493 assert.Equal(t, firstTid, omciMsg.TransactionID)
1494 assert.Equal(t, MibUploadNextResponseType, omciMsg.MessageType)
1495 assert.Equal(t, uint16(40), omciMsg.Length)
1496
1497 msgLayer := packet.Layer(LayerTypeMibUploadNextResponse)
1498 assert.NotNil(t, msgLayer)
1499
1500 uploadResponse, ok2 := msgLayer.(*MibUploadNextResponse)
1501 assert.True(t, ok2)
1502 assert.Equal(t, me.OnuDataClassID, uploadResponse.EntityClass)
1503 assert.Equal(t, uint16(0), uploadResponse.EntityInstance)
1504
1505 // Test serialization back to former string
1506 var options gopacket.SerializeOptions
1507 options.FixLengths = true
1508
1509 buffer := gopacket.NewSerializeBuffer()
1510 err = gopacket.SerializeLayers(buffer, options, omciMsg, uploadResponse)
1511 assert.NoError(t, err)
1512
1513 outgoingPacket := buffer.Bytes()
1514 reconstituted := packetToString(outgoingPacket)
1515 assert.Equal(t, strings.ToLower(packetString), reconstituted)
1516
1517 // Advance TID
1518 firstTid += 1
1519 }
1520}
1521
1522// TestUnsupportedG988ClassIDMibUploadNextResponse tests decoding of an Unknown class ID that is
1523// in the range of IDs assigned for G.988 use
1524func TestUnsupportedG988ClassIDMibUploadNextResponse(t *testing.T) {
1525 // The unsupported G.988 class ID below is 37 (0x0025), which is marked in the G.988
1526 // (11/2017) as 'Intentionally left blank). The encoded frame is a Get-Next
1527 // response with a single attribute 1 & 16 (0x8001) encoded.
1528 //
1529 tid := 3
1530 cid := 0x25
1531 eid := 1
1532 mask := 0x8000
1533 omci_hdr := "00032e0a"
1534 msg_hdr := "00020000"
1535 reported_me_hdr := "002500018000"
1536 attr := "0102030405060708090A0B0C0D0E0F101112131415161718191A"
1537 trailer := "0000002828ce00e2"
1538 msg := omci_hdr + msg_hdr + reported_me_hdr + attr + trailer
1539 data, err := stringToPacket(msg)
1540 assert.NoError(t, err)
1541
1542 // Decode packet (lazy this time)
1543 packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.Lazy)
1544 assert.NotNil(t, packet)
1545
1546 // OMCI Layer Contents are the
1547 // - TCI (2 bytes)
1548 // - Msg Type (1 byte)
1549 // - Device Ident (1 byte)
1550 //
1551 // payload is remaining layers (less optional length and MIC)
1552
1553 omciLayer := packet.Layer(LayerTypeOMCI)
1554 assert.NotNil(t, packet)
1555
1556 contents := omciLayer.LayerContents()
1557 payload := omciLayer.LayerPayload()
1558 assert.NotNil(t, contents)
1559 assert.NotNil(t, payload)
1560 assert.Equal(t, len(contents), len(omci_hdr)/2)
1561 assert.Equal(t, len(payload), len(msg_hdr+reported_me_hdr+attr)/2)
1562
1563 omciMsg, ok := omciLayer.(*OMCI)
1564 assert.True(t, ok)
1565 assert.Equal(t, uint16(tid), omciMsg.TransactionID)
1566 assert.Equal(t, MibUploadNextResponseType, omciMsg.MessageType)
1567 assert.Equal(t, uint16(40), omciMsg.Length)
1568
1569 // Message Layer contents for a MIB upload next response (baseline message set) are the
1570 // - OMCI Message Header (TCI, msg Type, ...) (4 bytes)
1571 //
1572 // Message Layer payload for a MIB upload next response are the
1573 // - ONU Data Class/Instance (4 bytes)
1574 // - Reported Managed Entity Class/Instance (4 bytes)
1575 // - Attribute Mask (2 bytes)
1576 // - Attributes
1577 // and zero-padding (but not length & MIC)
1578
1579 msgLayer := packet.Layer(LayerTypeMibUploadNextResponse)
1580 assert.NotNil(t, msgLayer)
1581
1582 contents = msgLayer.LayerContents()
1583 payload = msgLayer.LayerPayload()
1584 assert.NotNil(t, contents)
1585 assert.NotNil(t, payload)
1586 assert.Equal(t, len(msg_hdr)/2, len(contents))
1587 assert.Equal(t, len(reported_me_hdr+attr)/2, len(payload))
1588
1589 uploadResponse, ok2 := msgLayer.(*MibUploadNextResponse)
1590 assert.True(t, ok2)
1591 assert.NotNil(t, uploadResponse)
1592
1593 assert.Equal(t, me.OnuDataClassID, uploadResponse.EntityClass)
1594 assert.Equal(t, uint16(0), uploadResponse.EntityInstance)
1595 assert.Equal(t, me.ClassID(cid), uploadResponse.ReportedME.GetClassID())
1596 assert.Equal(t, uint16(eid), uploadResponse.ReportedME.GetEntityID())
1597 assert.Equal(t, uint16(mask), uploadResponse.ReportedME.GetAttributeMask())
1598
1599 name := "UnknownAttr_1"
1600 blobAttribute, err := uploadResponse.ReportedME.GetAttribute(name)
1601 assert.Nil(t, err)
1602 assert.NotNil(t, blobAttribute)
1603}
1604
1605func TestUnsupportedG988ClassIDMibUploadNextResponseAttributes(t *testing.T) {
1606 // Same as previous, but try different attribute mask combinations
1607 tid := 3
1608 cid := 0x25
1609 eid := 1
1610
1611 // There are a number of ranges for vendor ID use. List below picks one from
1612 // each of those ranges
1613 masks := []uint16{0x8001, 0x0000, 0x0001, 0x8000}
1614
1615 trailer := "0000002828ce00e2"
1616 attr := "0102030405060708090A0B0C0D0E0F101112131415161718191A"
1617
1618 for _, mask := range masks {
1619 hdr := fmt.Sprintf("00032e0a0002000000250001%04x", mask)
1620
1621 msg := hdr + attr + trailer
1622 data, err := stringToPacket(msg)
1623 assert.NoError(t, err)
1624
1625 packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.NoCopy)
1626 assert.NotNil(t, packet)
1627
1628 omciLayer := packet.Layer(LayerTypeOMCI)
1629 assert.NotNil(t, packet)
1630
1631 omciMsg, ok := omciLayer.(*OMCI)
1632 assert.True(t, ok)
1633 assert.Equal(t, uint16(tid), omciMsg.TransactionID)
1634 assert.Equal(t, MibUploadNextResponseType, omciMsg.MessageType)
1635 assert.Equal(t, uint16(40), omciMsg.Length)
1636
1637 msgLayer := packet.Layer(LayerTypeMibUploadNextResponse)
1638 assert.NotNil(t, msgLayer)
1639
1640 uploadResponse, ok2 := msgLayer.(*MibUploadNextResponse)
1641 assert.True(t, ok2)
1642 assert.NotNil(t, uploadResponse)
1643 assert.Equal(t, me.OnuDataClassID, uploadResponse.EntityClass)
1644 assert.Equal(t, uint16(0), uploadResponse.EntityInstance)
1645 assert.Equal(t, me.ClassID(cid), uploadResponse.ReportedME.GetClassID())
1646 assert.Equal(t, uint16(eid), uploadResponse.ReportedME.GetEntityID())
1647 assert.Equal(t, mask, uploadResponse.ReportedME.GetAttributeMask())
1648 }
1649}
1650
1651// TestUnsupportedVendorClassIDMibUploadNextResponse tests decoding of an Unknown class ID that is
1652// in the range of IDs assigned for vendor assignment
1653func TestUnsupportedVendorClassIDMibUploadNextResponse(t *testing.T) {
1654 tid := 3
1655 eid := 0
1656 mask := 0x8000
1657
1658 // There are a number of ranges for vendor ID use. List below picks one from
1659 // each of those ranges
1660 classIDs := []uint16{250, 355, 65500}
1661
1662 hdr := "00032e0a00020000"
1663 attr := "0102030405060708090A0B0C0D0E0F101112131415161718191A"
1664 trailer := "0000002828ce00e2"
1665
1666 for _, cid := range classIDs {
1667 cidToMask := fmt.Sprintf("%04x%04x%04x", cid, eid, mask)
1668 msg := hdr + cidToMask + attr + trailer
1669 data, err := stringToPacket(msg)
1670 assert.NoError(t, err)
1671
1672 packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.NoCopy)
1673 assert.NotNil(t, packet)
1674
1675 omciLayer := packet.Layer(LayerTypeOMCI)
1676 assert.NotNil(t, packet)
1677
1678 omciMsg, ok := omciLayer.(*OMCI)
1679 assert.True(t, ok)
1680 assert.Equal(t, uint16(tid), omciMsg.TransactionID)
1681 assert.Equal(t, MibUploadNextResponseType, omciMsg.MessageType)
1682 assert.Equal(t, uint16(40), omciMsg.Length)
1683
1684 msgLayer := packet.Layer(LayerTypeMibUploadNextResponse)
1685 assert.NotNil(t, msgLayer)
1686
1687 uploadResponse, ok2 := msgLayer.(*MibUploadNextResponse)
1688 assert.True(t, ok2)
1689 assert.NotNil(t, uploadResponse)
1690 assert.Equal(t, me.OnuDataClassID, uploadResponse.EntityClass)
1691 assert.Equal(t, uint16(0), uploadResponse.EntityInstance)
1692 assert.Equal(t, me.ClassID(cid), uploadResponse.ReportedME.GetClassID())
1693 assert.Equal(t, uint16(eid), uploadResponse.ReportedME.GetEntityID())
1694 assert.Equal(t, uint16(mask), uploadResponse.ReportedME.GetAttributeMask())
1695
1696 name := "UnknownAttr_1"
1697 blobAttribute, err := uploadResponse.ReportedME.GetAttribute(name)
1698
1699 assert.Nil(t, err)
1700 assert.NotNil(t, blobAttribute)
1701
1702 byteValue, ok3 := blobAttribute.([]uint8)
1703 assert.True(t, ok3)
1704 assert.NotNil(t, byteValue)
1705 }
1706}
1707
1708func TestMibUpload(t *testing.T) {
1709 mibUpload := "00304D0A000200000000000000000000" +
1710 "00000000000000000000000000000000" +
1711 "000000000000000000000028"
1712
1713 data, err := stringToPacket(mibUpload)
1714 assert.NoError(t, err)
1715
1716 packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.NoCopy)
1717 assert.NotNil(t, packet)
1718
1719 omciLayer := packet.Layer(LayerTypeOMCI)
1720 assert.NotNil(t, packet)
1721
1722 omciMsg, ok := omciLayer.(*OMCI)
1723 assert.True(t, ok)
1724 assert.Equal(t, uint16(0x30), omciMsg.TransactionID)
1725 assert.Equal(t, MibUploadRequestType, omciMsg.MessageType)
1726 assert.Equal(t, uint16(40), omciMsg.Length)
1727
1728 msgLayer := packet.Layer(LayerTypeMibUploadRequest)
1729 assert.NotNil(t, msgLayer)
1730
1731 uploadRequest, ok2 := msgLayer.(*MibUploadRequest)
1732 assert.True(t, ok2)
1733 assert.Equal(t, me.OnuDataClassID, uploadRequest.EntityClass)
1734 assert.Equal(t, uint16(0), uploadRequest.EntityInstance)
1735
1736 // Test serialization back to former string
1737 var options gopacket.SerializeOptions
1738 options.FixLengths = true
1739
1740 buffer := gopacket.NewSerializeBuffer()
1741 err = gopacket.SerializeLayers(buffer, options, omciMsg, uploadRequest)
1742 assert.NoError(t, err)
1743
1744 outgoingPacket := buffer.Bytes()
1745 reconstituted := packetToString(outgoingPacket)
1746 assert.Equal(t, strings.ToLower(mibUpload), reconstituted)
1747}