Gitiles
Code Review Sign In
gerrit.opencord.org / omci-lib-go / refs/tags/v2.0.0 / . / mibupload_test.go
blob: 8fcc983b4dd9528722b1e11ec3eb2ff7d74b5ce5 [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
616 // TODO: Implement and test
617
618 packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.NoCopy)
619 assert.NotNil(t, packet)
620
621 omciLayer := packet.Layer(LayerTypeOMCI)
622 assert.NotNil(t, omciLayer)
623
624 omciMsg, ok := omciLayer.(*OMCI)
625 assert.True(t, ok)
626 assert.NotNil(t, omciMsg)
627 assert.Equal(t, LayerTypeOMCI, omciMsg.LayerType())
628 assert.Equal(t, LayerTypeOMCI, omciMsg.CanDecode())
629 assert.Equal(t, LayerTypeMibUploadNextResponse, omciMsg.NextLayerType())
630 assert.Equal(t, uint16(0x0286), omciMsg.TransactionID)
631 assert.Equal(t, MibUploadNextResponseType, omciMsg.MessageType)
632 assert.Equal(t, ExtendedIdent, omciMsg.DeviceIdentifier)
633 assert.Equal(t, uint16(3*(8+24)), omciMsg.Length)
634
635 msgLayer := packet.Layer(LayerTypeMibUploadNextResponse)
636 assert.NotNil(t, msgLayer)
637
638 response, ok2 := msgLayer.(*MibUploadNextResponse)
639 assert.True(t, ok2)
640 assert.NotNil(t, response)
641 assert.Equal(t, LayerTypeMibUploadNextResponse, response.LayerType())
642 assert.Equal(t, LayerTypeMibUploadNextResponse, response.CanDecode())
643 assert.Equal(t, gopacket.LayerTypePayload, response.NextLayerType())
644 assert.Equal(t, me.PriorityQueueClassID, response.ReportedME.GetClassID())
645 assert.Equal(t, uint16(0), response.ReportedME.GetEntityID())
646
647 attributes := me.AttributeValueMap{
648 "QueueConfigurationOption": byte(1),
649 "MaximumQueueSize": uint16(0x1234),
650 "AllocatedQueueSize": uint16(0x4321),
651 "DiscardBlockCounterResetInterval": uint16(0x5678),
652 "ThresholdValueForDiscardedBlocksDueToBufferOverflow": uint16(0x8765),
653 "RelatedPort": uint32(16842752),
654 "TrafficSchedulerPointer": uint16(0xFFBB),
655 "Weight": byte(1),
656 "BackPressureOperation": uint16(0x1234),
657 "BackPressureTime": uint32(0),
658 "BackPressureOccurQueueThreshold": uint16(0x6789),
659 }
660 // 01 1234 4321 5678 8765 01010000 FFBB 01 1234 00000000 6789
661 // 01123443215678876501010000FFBB011234000000006789
662 // 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4
663 for name, value := range attributes {
664 pktValue, err := response.ReportedME.GetAttribute(name)
665 assert.Nil(t, err)
666 assert.Equal(t, value, pktValue)
667 }
668 // Other two are the same, just different managed entity IDs
669
670 assert.Equal(t, 2, len(response.AdditionalMEs))
671 assert.Equal(t, me.PriorityQueueClassID, response.AdditionalMEs[0].GetClassID())
672 assert.Equal(t, uint16(1), response.AdditionalMEs[0].GetEntityID())
673 for name, value := range attributes {
674 pktValue, err := response.AdditionalMEs[0].GetAttribute(name)
675 assert.Nil(t, err)
676 assert.Equal(t, value, pktValue)
677 }
678 assert.Equal(t, me.PriorityQueueClassID, response.AdditionalMEs[1].GetClassID())
679 assert.Equal(t, uint16(2), response.AdditionalMEs[1].GetEntityID())
680 for name, value := range attributes {
681 pktValue, err := response.AdditionalMEs[1].GetAttribute(name)
682 assert.Nil(t, err)
683 assert.Equal(t, value, pktValue)
684 }
685 // Verify string output for message
686 packetString := packet.String()
687 assert.NotZero(t, len(packetString))
688}
689
690func TestMibUploadNextResponseDecodeExtendedMaxLength(t *testing.T) {
691 // Max payload after header length field and not including MIC is 1966 octets
692 maxPayloadLen := MaxExtendedLength - 10 - 4
693
694 // Payload is AttrLen (2) + ME Hdr (6) + attributes which is 30 octets
695 // below. That allows 65 'common' payloads with a remainder of 16 octets
696 // to fill with another ME
697 commonPayloadFmt := "00160115%04xffc001123443215678876501010000FFBB01123487654321"
698 lastPayload := "00080115000078001234432156788765"
699 msgHeader := fmt.Sprintf("02862e0b00020000%04x", maxPayloadLen)
700 numCommon := 65
701
702 goodMessage := msgHeader + fmt.Sprintf(commonPayloadFmt, 0)
703 for instance := 1; instance < numCommon; instance++ {
704 goodMessage += fmt.Sprintf(commonPayloadFmt, instance)
705 }
706 goodMessage += lastPayload
707
708 data, err := stringToPacket(goodMessage)
709 assert.NoError(t, err)
710 assert.Equal(t, MaxExtendedLength-4, len(data))
711
712 packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.NoCopy)
713 assert.NotNil(t, packet)
714
715 omciLayer := packet.Layer(LayerTypeOMCI)
716 assert.NotNil(t, omciLayer)
717
718 omciMsg, ok := omciLayer.(*OMCI)
719 assert.True(t, ok)
720 assert.NotNil(t, omciMsg)
721 assert.Equal(t, LayerTypeOMCI, omciMsg.LayerType())
722 assert.Equal(t, LayerTypeOMCI, omciMsg.CanDecode())
723 assert.Equal(t, LayerTypeMibUploadNextResponse, omciMsg.NextLayerType())
724 assert.Equal(t, uint16(0x0286), omciMsg.TransactionID)
725 assert.Equal(t, MibUploadNextResponseType, omciMsg.MessageType)
726 assert.Equal(t, ExtendedIdent, omciMsg.DeviceIdentifier)
727 assert.Equal(t, uint16(maxPayloadLen), omciMsg.Length)
728
729 msgLayer := packet.Layer(LayerTypeMibUploadNextResponse)
730 assert.NotNil(t, msgLayer)
731
732 response, ok2 := msgLayer.(*MibUploadNextResponse)
733 assert.True(t, ok2)
734 assert.NotNil(t, response)
735 assert.Equal(t, LayerTypeMibUploadNextResponse, response.LayerType())
736 assert.Equal(t, LayerTypeMibUploadNextResponse, response.CanDecode())
737 assert.Equal(t, gopacket.LayerTypePayload, response.NextLayerType())
738 assert.Equal(t, me.PriorityQueueClassID, response.ReportedME.GetClassID())
739 assert.Equal(t, uint16(0), response.ReportedME.GetEntityID())
740
741 attributes := me.AttributeValueMap{
742 "QueueConfigurationOption": byte(1),
743 "MaximumQueueSize": uint16(0x1234),
744 "AllocatedQueueSize": uint16(0x4321),
745 "DiscardBlockCounterResetInterval": uint16(0x5678),
746 "ThresholdValueForDiscardedBlocksDueToBufferOverflow": uint16(0x8765),
747 "RelatedPort": uint32(16842752),
748 "TrafficSchedulerPointer": uint16(0xFFBB),
749 "Weight": byte(1),
750 "BackPressureOperation": uint16(0x1234),
751 "BackPressureTime": uint32(0x87654321),
752 }
753 lastPayloadAttributes := me.AttributeValueMap{
754 "MaximumQueueSize": uint16(0x1234),
755 "AllocatedQueueSize": uint16(0x4321),
756 "DiscardBlockCounterResetInterval": uint16(0x5678),
757 "ThresholdValueForDiscardedBlocksDueToBufferOverflow": uint16(0x8765),
758 }
759 // Check first ME that is stored in same location as in baseline message
760 for name, value := range attributes {
761 pktValue, err := response.ReportedME.GetAttribute(name)
762 assert.Nil(t, err)
763 assert.Equal(t, value, pktValue)
764 }
765 // Check remainder of the package = (numCommon - 1) + trailing me
766 assert.Equal(t, numCommon, len(response.AdditionalMEs))
767 for index, additional := range response.AdditionalMEs {
768 if index == numCommon-1 {
769 break
770 }
771 assert.Equal(t, me.PriorityQueueClassID, additional.GetClassID())
772 assert.Equal(t, uint16(index+1), additional.GetEntityID())
773 for name, value := range attributes {
774 pktValue, err := additional.GetAttribute(name)
775 assert.Nil(t, err)
776 assert.Equal(t, value, pktValue)
777 }
778 }
779 // And check the last one
780 assert.Equal(t, me.PriorityQueueClassID, response.AdditionalMEs[numCommon-1].GetClassID())
781 assert.Equal(t, uint16(0), response.AdditionalMEs[numCommon-1].GetEntityID())
782 for name, value := range lastPayloadAttributes {
783 pktValue, err := response.AdditionalMEs[numCommon-1].GetAttribute(name)
784 assert.Nil(t, err)
785 assert.Equal(t, value, pktValue)
786 }
787 // Verify string output for message
788 packetString := packet.String()
789 assert.NotZero(t, len(packetString))
790}
791
792func TestMibUploadNextResponseSerialize(t *testing.T) {
793 goodMessage := "02862e0a0002000001150000fff0000000000000000000010100000000010002000000030004000500000028"
794
795 omciLayer := &OMCI{
796 TransactionID: 0x0286,
797 MessageType: MibUploadNextResponseType,
798 // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
799 // Length: 0x28, // Optional, defaults to 40 octets
800 }
801 paramData := me.ParamData{
802 EntityID: uint16(0),
803 Attributes: me.AttributeValueMap{
804 "QueueConfigurationOption": byte(0),
805 "MaximumQueueSize": uint16(0),
806 "AllocatedQueueSize": uint16(0),
807 "DiscardBlockCounterResetInterval": uint16(0),
808 "ThresholdValueForDiscardedBlocksDueToBufferOverflow": uint16(0),
809 "RelatedPort": uint32(16842752),
810 "TrafficSchedulerPointer": uint16(0),
811 "Weight": byte(1),
812 "BackPressureOperation": uint16(2),
813 "BackPressureTime": uint32(3),
814 "BackPressureOccurQueueThreshold": uint16(4),
815 "BackPressureClearQueueThreshold": uint16(5),
816 },
817 }
818 reportedME, err := me.NewPriorityQueue(paramData)
819 assert.NotNil(t, err)
820 assert.Equal(t, err.StatusCode(), me.Success)
821
822 request := &MibUploadNextResponse{
823 MeBasePacket: MeBasePacket{
824 EntityClass: me.OnuDataClassID,
825 EntityInstance: uint16(0),
826 },
827 ReportedME: *reportedME,
828 }
829 // Test serialization back to former string
830 var options gopacket.SerializeOptions
831 options.FixLengths = true
832
833 buffer := gopacket.NewSerializeBuffer()
834 omciErr := gopacket.SerializeLayers(buffer, options, omciLayer, request)
835 assert.NoError(t, omciErr)
836
837 outgoingPacket := buffer.Bytes()
838 reconstituted := packetToString(outgoingPacket)
839 assert.Equal(t, strings.ToLower(goodMessage), reconstituted)
840}
841
842func TestMibUploadNextResponseZeroTICSerialize(t *testing.T) {
843 omciLayer := &OMCI{
844 TransactionID: 0x0,
845 MessageType: MibUploadNextResponseType,
846 // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
847 // Length: 0x28, // Optional, defaults to 40 octets
848 }
849 paramData := me.ParamData{
850 EntityID: uint16(0),
851 Attributes: me.AttributeValueMap{
852 "QueueConfigurationOption": byte(0),
853 "MaximumQueueSize": uint16(0),
854 "AllocatedQueueSize": uint16(0),
855 "DiscardBlockCounterResetInterval": uint16(0),
856 "ThresholdValueForDiscardedBlocksDueToBufferOverflow": uint16(0),
857 "RelatedPort": uint32(16842752),
858 "TrafficSchedulerPointer": uint16(0),
859 "Weight": byte(1),
860 "BackPressureOperation": uint16(2),
861 "BackPressureTime": uint32(3),
862 "BackPressureOccurQueueThreshold": uint16(4),
863 "BackPressureClearQueueThreshold": uint16(5),
864 },
865 }
866 reportedME, err := me.NewPriorityQueue(paramData)
867 assert.NotNil(t, err)
868 assert.Equal(t, err.StatusCode(), me.Success)
869
870 request := &MibUploadNextResponse{
871 MeBasePacket: MeBasePacket{
872 EntityClass: me.OnuDataClassID,
873 EntityInstance: uint16(0),
874 },
875 ReportedME: *reportedME,
876 }
877 // Test serialization back to former string
878 var options gopacket.SerializeOptions
879 options.FixLengths = true
880
881 buffer := gopacket.NewSerializeBuffer()
882 omciErr := gopacket.SerializeLayers(buffer, options, omciLayer, request)
883 assert.Error(t, omciErr)
884}
885
886func TestMibUploadNextResponseSerializeExtendedOneMe(t *testing.T) {
887 firstMe := "001801150000ffe001123443215678876501010000FFBB011234000000006789"
888 goodMessage := "02862e0b000200000020" + firstMe
889
890 omciLayer := &OMCI{
891 TransactionID: 0x0286,
892 MessageType: MibUploadNextResponseType,
893 DeviceIdentifier: ExtendedIdent,
894 }
895 paramData := me.ParamData{
896 EntityID: uint16(0),
897 Attributes: me.AttributeValueMap{
898 "QueueConfigurationOption": byte(1),
899 "MaximumQueueSize": uint16(0x1234),
900 "AllocatedQueueSize": uint16(0x4321),
901 "DiscardBlockCounterResetInterval": uint16(0x5678),
902 "ThresholdValueForDiscardedBlocksDueToBufferOverflow": uint16(0x8765),
903 "RelatedPort": uint32(16842752),
904 "TrafficSchedulerPointer": uint16(0xFFBB),
905 "Weight": byte(1),
906 "BackPressureOperation": uint16(0x1234),
907 "BackPressureTime": uint32(0),
908 "BackPressureOccurQueueThreshold": uint16(0x6789),
909 },
910 }
911 reportedME, err := me.NewPriorityQueue(paramData)
912 assert.NotNil(t, err)
913 assert.Equal(t, err.StatusCode(), me.Success)
914
915 request := &MibUploadNextResponse{
916 MeBasePacket: MeBasePacket{
917 EntityClass: me.OnuDataClassID,
918 EntityInstance: uint16(0),
919 Extended: true,
920 },
921 ReportedME: *reportedME,
922 }
923 // Test serialization back to former string
924 var options gopacket.SerializeOptions
925 options.FixLengths = true
926
927 buffer := gopacket.NewSerializeBuffer()
928 omciErr := gopacket.SerializeLayers(buffer, options, omciLayer, request)
929 assert.NoError(t, omciErr)
930
931 outgoingPacket := buffer.Bytes()
932 reconstituted := packetToString(outgoingPacket)
933 assert.Equal(t, strings.ToLower(goodMessage), reconstituted)
934}
935
936func TestMibUploadNextResponseSerializeExtendedTwoMe(t *testing.T) {
937 first := "001801150000ffe001123443215678876501010000FFBB011234000000006789"
938 second := "001801150001ffe001123443215678876501010000FFBB011234000000006789"
939 goodMessage := "02862e0b000200000040" + first + second
940
941 omciLayer := &OMCI{
942 TransactionID: 0x0286,
943 MessageType: MibUploadNextResponseType,
944 DeviceIdentifier: ExtendedIdent,
945 }
946 paramData := me.ParamData{
947 EntityID: uint16(0),
948 Attributes: me.AttributeValueMap{
949 "QueueConfigurationOption": byte(1),
950 "MaximumQueueSize": uint16(0x1234),
951 "AllocatedQueueSize": uint16(0x4321),
952 "DiscardBlockCounterResetInterval": uint16(0x5678),
953 "ThresholdValueForDiscardedBlocksDueToBufferOverflow": uint16(0x8765),
954 "RelatedPort": uint32(16842752),
955 "TrafficSchedulerPointer": uint16(0xFFBB),
956 "Weight": byte(1),
957 "BackPressureOperation": uint16(0x1234),
958 "BackPressureTime": uint32(0),
959 "BackPressureOccurQueueThreshold": uint16(0x6789),
960 },
961 }
962 reportedME, err := me.NewPriorityQueue(paramData)
963 assert.NotNil(t, err)
964 assert.Equal(t, err.StatusCode(), me.Success)
965 additional := make([]me.ManagedEntity, 1)
966
967 for inst := 1; inst < 2; inst++ {
968 paramData.EntityID = uint16(inst)
969 entity, _ := me.NewPriorityQueue(paramData)
970 additional[inst-1] = *entity
971 }
972 request := &MibUploadNextResponse{
973 MeBasePacket: MeBasePacket{
974 EntityClass: me.OnuDataClassID,
975 EntityInstance: uint16(0),
976 Extended: true,
977 },
978 ReportedME: *reportedME,
979 AdditionalMEs: additional,
980 }
981 // Test serialization back to former string
982 var options gopacket.SerializeOptions
983 options.FixLengths = true
984
985 buffer := gopacket.NewSerializeBuffer()
986 omciErr := gopacket.SerializeLayers(buffer, options, omciLayer, request)
987 assert.NoError(t, omciErr)
988
989 outgoingPacket := buffer.Bytes()
990 reconstituted := packetToString(outgoingPacket)
991 assert.Equal(t, strings.ToLower(goodMessage), reconstituted)
992}
993
994func TestMibUploadNextResponseSerializeExtendedThreeMe(t *testing.T) {
995 first := "001801150000ffe001123443215678876501010000FFBB011234000000006789"
996 second := "001801150001ffe001123443215678876501010000FFBB011234000000006789"
997 third := "001801150002ffe001123443215678876501010000FFBB011234000000006789"
998 goodMessage := "02862e0b000200000060" + first + second + third
999
1000 omciLayer := &OMCI{
1001 TransactionID: 0x0286,
1002 MessageType: MibUploadNextResponseType,
1003 DeviceIdentifier: ExtendedIdent,
1004 }
1005 paramData := me.ParamData{
1006 EntityID: uint16(0),
1007 Attributes: me.AttributeValueMap{
1008 "QueueConfigurationOption": byte(1),
1009 "MaximumQueueSize": uint16(0x1234),
1010 "AllocatedQueueSize": uint16(0x4321),
1011 "DiscardBlockCounterResetInterval": uint16(0x5678),
1012 "ThresholdValueForDiscardedBlocksDueToBufferOverflow": uint16(0x8765),
1013 "RelatedPort": uint32(16842752),
1014 "TrafficSchedulerPointer": uint16(0xFFBB),
1015 "Weight": byte(1),
1016 "BackPressureOperation": uint16(0x1234),
1017 "BackPressureTime": uint32(0),
1018 "BackPressureOccurQueueThreshold": uint16(0x6789),
1019 },
1020 }
1021 reportedME, err := me.NewPriorityQueue(paramData)
1022 assert.NotNil(t, err)
1023 assert.Equal(t, err.StatusCode(), me.Success)
1024 additional := make([]me.ManagedEntity, 2)
1025
1026 for inst := 1; inst < 3; inst++ {
1027 paramData.EntityID = uint16(inst)
1028 entity, _ := me.NewPriorityQueue(paramData)
1029 additional[inst-1] = *entity
1030 }
1031 request := &MibUploadNextResponse{
1032 MeBasePacket: MeBasePacket{
1033 EntityClass: me.OnuDataClassID,
1034 EntityInstance: uint16(0),
1035 Extended: true,
1036 },
1037 ReportedME: *reportedME,
1038 AdditionalMEs: additional,
1039 }
1040 // Test serialization back to former string
1041 var options gopacket.SerializeOptions
1042 options.FixLengths = true
1043
1044 buffer := gopacket.NewSerializeBuffer()
1045 omciErr := gopacket.SerializeLayers(buffer, options, omciLayer, request)
1046 assert.NoError(t, omciErr)
1047
1048 outgoingPacket := buffer.Bytes()
1049 reconstituted := packetToString(outgoingPacket)
1050 assert.Equal(t, strings.ToLower(goodMessage), reconstituted)
1051}
1052
1053func TestMibUploadNextResponseSerializeExtendedMaxFrame(t *testing.T) {
1054 // Max payload after header length field and not including MIC is 1966 octets
1055 maxPayloadLen := MaxExtendedLength - 10 - 4
1056
1057 // Payload is AttrLen (2) + ME Hdr (6) + attributes which is 30 octets
1058 // below. That allows 65 'common' payloads with a remainder of 16 octets
1059 // to fill with another ME
1060 commonPayloadFmt := "00160115%04xffc001123443215678876501010000FFBB01123487654321"
1061 lastPayload := "00080115000078001234432156788765"
1062 msgHeader := fmt.Sprintf("02862e0b00020000%04x", maxPayloadLen)
1063 numCommon := 65
1064
1065 goodMessage := msgHeader + fmt.Sprintf(commonPayloadFmt, 0)
1066 for instance := 1; instance < numCommon; instance++ {
1067 goodMessage += fmt.Sprintf(commonPayloadFmt, instance)
1068 }
1069 goodMessage += lastPayload
1070
1071 omciLayer := &OMCI{
1072 TransactionID: 0x0286,
1073 MessageType: MibUploadNextResponseType,
1074 DeviceIdentifier: ExtendedIdent,
1075 }
1076 paramData := me.ParamData{
1077 EntityID: uint16(0),
1078 Attributes: me.AttributeValueMap{
1079 "QueueConfigurationOption": byte(1),
1080 "MaximumQueueSize": uint16(0x1234),
1081 "AllocatedQueueSize": uint16(0x4321),
1082 "DiscardBlockCounterResetInterval": uint16(0x5678),
1083 "ThresholdValueForDiscardedBlocksDueToBufferOverflow": uint16(0x8765),
1084 "RelatedPort": uint32(16842752),
1085 "TrafficSchedulerPointer": uint16(0xFFBB),
1086 "Weight": byte(1),
1087 "BackPressureOperation": uint16(0x1234),
1088 "BackPressureTime": uint32(0x87654321),
1089 },
1090 }
1091 reportedME, err := me.NewPriorityQueue(paramData)
1092 assert.NotNil(t, err)
1093 assert.Equal(t, err.StatusCode(), me.Success)
1094 request := &MibUploadNextResponse{
1095 MeBasePacket: MeBasePacket{
1096 EntityClass: me.OnuDataClassID,
1097 EntityInstance: uint16(0),
1098 Extended: true,
1099 },
1100 ReportedME: *reportedME,
1101 AdditionalMEs: make([]me.ManagedEntity, numCommon),
1102 }
1103 for instance := 0; instance < numCommon-1; instance++ {
1104 paramData.EntityID = uint16(instance + 1)
1105 reportedME, err = me.NewPriorityQueue(paramData)
1106 assert.NotNil(t, err)
1107 assert.Equal(t, err.StatusCode(), me.Success)
1108 request.AdditionalMEs[instance] = *reportedME
1109 }
1110 lastMeParams := me.ParamData{
1111 EntityID: uint16(0),
1112 Attributes: me.AttributeValueMap{
1113 "MaximumQueueSize": uint16(0x1234),
1114 "AllocatedQueueSize": uint16(0x4321),
1115 "DiscardBlockCounterResetInterval": uint16(0x5678),
1116 "ThresholdValueForDiscardedBlocksDueToBufferOverflow": uint16(0x8765),
1117 },
1118 }
1119 // And the last one to fully fill out the maximum sized frame
1120 reportedME, err = me.NewPriorityQueue(lastMeParams)
1121 assert.NotNil(t, err)
1122 assert.Equal(t, err.StatusCode(), me.Success)
1123 request.AdditionalMEs[numCommon-1] = *reportedME
1124
1125 // Test serialization back to former string
1126 var options gopacket.SerializeOptions
1127 options.FixLengths = true
1128
1129 buffer := gopacket.NewSerializeBuffer()
1130 omciErr := gopacket.SerializeLayers(buffer, options, omciLayer, request)
1131 assert.NoError(t, omciErr)
1132
1133 outgoingPacket := buffer.Bytes()
1134 reconstituted := packetToString(outgoingPacket)
1135 assert.Equal(t, strings.ToLower(goodMessage), reconstituted)
1136}
1137
1138func TestMibUploadNextResponseSerializeExtendedMaxFramePlusOneByteTooMany(t *testing.T) {
1139 // Identical to last test but last ME has one extra octet
1140 numCommon := 65
1141 omciLayer := &OMCI{
1142 TransactionID: 0x0286,
1143 MessageType: MibUploadNextResponseType,
1144 DeviceIdentifier: ExtendedIdent,
1145 }
1146 paramData := me.ParamData{
1147 EntityID: uint16(0),
1148 Attributes: me.AttributeValueMap{
1149 "QueueConfigurationOption": byte(1),
1150 "MaximumQueueSize": uint16(0x1234),
1151 "AllocatedQueueSize": uint16(0x4321),
1152 "DiscardBlockCounterResetInterval": uint16(0x5678),
1153 "ThresholdValueForDiscardedBlocksDueToBufferOverflow": uint16(0x8765),
1154 "RelatedPort": uint32(16842752),
1155 "TrafficSchedulerPointer": uint16(0xFFBB),
1156 "Weight": byte(1),
1157 "BackPressureOperation": uint16(0x1234),
1158 "BackPressureTime": uint32(0x87654321),
1159 },
1160 }
1161 reportedME, err := me.NewPriorityQueue(paramData)
1162 assert.NotNil(t, err)
1163 assert.Equal(t, err.StatusCode(), me.Success)
1164 request := &MibUploadNextResponse{
1165 MeBasePacket: MeBasePacket{
1166 EntityClass: me.OnuDataClassID,
1167 EntityInstance: uint16(0),
1168 Extended: true,
1169 },
1170 ReportedME: *reportedME,
1171 AdditionalMEs: make([]me.ManagedEntity, numCommon),
1172 }
1173 for instance := 0; instance < numCommon-1; instance++ {
1174 paramData.EntityID = uint16(instance + 1)
1175 reportedME, err = me.NewPriorityQueue(paramData)
1176 assert.NotNil(t, err)
1177 assert.Equal(t, err.StatusCode(), me.Success)
1178 request.AdditionalMEs[instance] = *reportedME
1179 }
1180 lastMeParams := me.ParamData{
1181 EntityID: uint16(0),
1182 Attributes: me.AttributeValueMap{
1183 "QueueConfigurationOption": byte(1), // This is the extra byte
1184 "MaximumQueueSize": uint16(0x1234),
1185 "AllocatedQueueSize": uint16(0x4321),
1186 "DiscardBlockCounterResetInterval": uint16(0x5678),
1187 "ThresholdValueForDiscardedBlocksDueToBufferOverflow": uint16(0x8765),
1188 },
1189 }
1190 // And the last one to fully fill out the maximum sized frame
1191 reportedME, err = me.NewPriorityQueue(lastMeParams)
1192 assert.NotNil(t, err)
1193 assert.Equal(t, err.StatusCode(), me.Success)
1194 request.AdditionalMEs[numCommon-1] = *reportedME
1195
1196 // Test serialization back to former string
1197 var options gopacket.SerializeOptions
1198 options.FixLengths = true
1199
1200 buffer := gopacket.NewSerializeBuffer()
1201 omciErr := gopacket.SerializeLayers(buffer, options, omciLayer, request)
1202 assert.Error(t, omciErr)
1203}
1204
1205func TestMibUploadNextResponseBadCommandNumberDecode(t *testing.T) {
1206 // Test of a MIB Upload next Response that results when an invalid command number.
1207 // Note that if all attributes of a managed entity do not fit within one MIB
1208 // upload next response message, the attributes will be split over several
1209 // messages. The OLT can use the information in the attribute mask to determine
1210 // which attribute values are reported in which MIB upload next response message.
1211 //TODO: Implement
1212}
1213
1214func TestMibUploadNextResponseBadCommandNumberSerialize(t *testing.T) {
1215 // Test of a MIB Upload next Response that results when an invalid command number
1216 // is requested.
1217 //TODO: Implement
1218}
1219
1220func TestMibUploadNextSequence(t *testing.T) {
1221 mibUploadNextSequence := [...]string{
1222 "00032e0a00020000000200008000000000000000000000000000000000000000000000000000000000000028",
1223 "00042e0a0002000000050101f0002f2f05202020202020202020202020202020202020202000000000000028",
1224 "00052e0a00020000000501010f80202020202020202020202020202020202020202000000000000000000028",
1225 "00062e0a0002000000050104f000303001202020202020202020202020202020202020202000000000000028",
1226 "00072e0a00020000000501040f80202020202020202020202020202020202020202000000000000000000028",
1227 "00082e0a0002000000050180f000f8f801202020202020202020202020202020202020202000000000000028",
1228 "00092e0a00020000000501800f80202020202020202020202020202020202020202000000000000000000028",
1229 "000a2e0a0002000000060101f0002f054252434d12345678000000000000000000000000000c000000000028",
1230 "000b2e0a00020000000601010f004252434d0000000000000000000000000000000000000000000000000028",
1231 "000c2e0a000200000006010100f8202020202020202020202020202020202020202000000000000000000028",
1232 "000d2e0a00020000000601010004000000000000000000000000000000000000000000000000000000000028",
1233 "000e2e0a0002000000060104f00030014252434d12345678000000000000000000000000000c000000000028",
1234 "000f2e0a00020000000601040f004252434d0000000000000000000000000000000000000000000000000028",
1235 "00102e0a000200000006010400f8202020202020202020202020202020202020202000000800000000000028",
1236 "00112e0a00020000000601040004000000000000000000000000000000000000000000000000000000000028",
1237 "00122e0a0002000000060180f000f8014252434d12345678000000000000000000000000000c000000000028",
1238 "00132e0a00020000000601800f004252434d0000000000000000000000000000000000000000000000000028",
1239 "00142e0a000200000006018000f8202020202020202020202020202020202020202000084040000000000028",
1240 "00152e0a00020000000601800004000000000000000000000000000000000000000000000000000000000028",
1241 "00162e0a0002000000070000f0003530323247574f3236363230303301010100000000000000000000000028",
1242 "00172e0a0002000000070001f0003530323247574f3236363230303300000100000000000000000000000028",
1243 "00182e0a0002000000830000c000202020202020202020202020202020202020202020202020000000000028",
1244 "00192e0a00020000008300002000202020202020202020202020202000000000000000000000000000000028",
1245 "001a2e0a00020000008300001000000000000000000000000000000000000000000000000000000000000028",
1246 "001b2e0a0002000000850000ffe0000000000000000000000000000000000000000000000000000000000028",
1247 "001c2e0a0002000000860001c00000001018aaaa000000000000000000000000000000000000000000000028",
1248 "001d2e0a00020000008600012000000000000000000000000000000000000000000000000000000000000028",
1249 "001e2e0a00020000008600011f80000000000000000000000000000000000000000000000000000000000028",
1250 "001f2e0a00020000008600010078000000000000000000000000000000000000000000000000000000000028",
1251 "00202e0a00020000008600010004000000000000000000000000000000000000000000000000000000000028",
1252 "00212e0a00020000008600010002000000000000000000000000000000000000000000000000000000000028",
1253 "00222e0a0002000001000000e0004252434d00000000000000000000000000004252434d1234567800000028",
1254 "00232e0a00020000010000001f80000000000000000000000000000000000000000000000000000000000028",
1255 "00242e0a00020000010000000040000000000000000000000000000000000000000000000000000000000028",
1256 "00252e0a00020000010000000038000000000000000000000000000003000000000000000000000000000028",
1257 "00262e0a0002000001010000f80042564d344b3030425241303931352d3030383300b3000001010000000028",
1258 "00272e0a000200000101000007f8000000010020027c85630016000030000000000000000000000000000028",
1259 "00282e0a0002000001068000e00000ff01010000000000000000000000000000000000000000000000000028",
1260 "00292e0a0002000001068001e00000ff01010000000000000000000000000000000000000000000000000028",
1261 "002a2e0a0002000001068002e00000ff01010000000000000000000000000000000000000000000000000028",
1262 "002b2e0a0002000001068003e00000ff01010000000000000000000000000000000000000000000000000028",
1263 "002c2e0a0002000001068004e00000ff01010000000000000000000000000000000000000000000000000028",
1264 "002d2e0a0002000001068005e00000ff01010000000000000000000000000000000000000000000000000028",
1265 "002e2e0a0002000001068006e00000ff01010000000000000000000000000000000000000000000000000028",
1266 "002f2e0a0002000001068007e00000ff01010000000000000000000000000000000000000000000000000028",
1267 "00302e0a0002000001078001ffff01000800300000050900000000ffff000000008181000000000000000028",
1268 "00312e0a0002000001080401f000000000000401000000000000000000000000000000000000000000000028",
1269 "00322e0a0002000001150401fff0000080008000000000040100000000010000000000000000000000000028",
1270 "00332e0a0002000001150401000f0200020002000200ffff0900000000000000000000000000000000000028",
1271 "00342e0a0002000001150402fff0000080008000000000040100010000010000000000000000000000000028",
1272 "00352e0a0002000001150402000f0200020002000200ffff0900000000000000000000000000000000000028",
1273 "00362e0a0002000001150403fff0000080008000000000040100020000010000000000000000000000000028",
1274 "00372e0a0002000001150403000f0200020002000200ffff0900000000000000000000000000000000000028",
1275 "00382e0a0002000001150404fff0000080008000000000040100030000010000000000000000000000000028",
1276 "00392e0a0002000001150404000f0200020002000200ffff0900000000000000000000000000000000000028",
1277 "003a2e0a0002000001150405fff0000080008000000000040100040000010000000000000000000000000028",
1278 "003b2e0a0002000001150405000f0200020002000200ffff0900000000000000000000000000000000000028",
1279 "003c2e0a0002000001150406fff0000080008000000000040100050000010000000000000000000000000028",
1280 "003d2e0a0002000001150406000f0200020002000200ffff0900000000000000000000000000000000000028",
1281 "003e2e0a0002000001150407fff0000080008000000000040100060000010000000000000000000000000028",
1282 "003f2e0a0002000001150407000f0200020002000200ffff0900000000000000000000000000000000000028",
1283 "00402e0a0002000001150408fff0000080008000000000040100070000010000000000000000000000000028",
1284 "00412e0a0002000001150408000f0200020002000200ffff0900000000000000000000000000000000000028",
1285 "00422e0a0002000001158000fff0000100010000000000800000000000010000000000000000000000000028",
1286 "00432e0a0002000001158000000f0200020002000200ffff0900000000000000000000000000000000000028",
1287 "00442e0a0002000001158001fff0000100010000000000800000010000010000000000000000000000000028",
1288 "00452e0a0002000001158001000f0200020002000200ffff0900000000000000000000000000000000000028",
1289 "00462e0a0002000001158002fff0000100010000000000800000020000010000000000000000000000000028",
1290 "00472e0a0002000001158002000f0200020002000200ffff0900000000000000000000000000000000000028",
1291 "00482e0a0002000001158003fff0000100010000000000800000030000010000000000000000000000000028",
1292 "00492e0a0002000001158003000f0200020002000200ffff0900000000000000000000000000000000000028",
1293 "004a2e0a0002000001158004fff0000100010000000000800000040000010000000000000000000000000028",
1294 "004b2e0a0002000001158004000f0200020002000200ffff0900000000000000000000000000000000000028",
1295 "004c2e0a0002000001158005fff0000100010000000000800000050000010000000000000000000000000028",
1296 "004d2e0a0002000001158005000f0200020002000200ffff0900000000000000000000000000000000000028",
1297 "004e2e0a0002000001158006fff0000100010000000000800000060000010000000000000000000000000028",
1298 "004f2e0a0002000001158006000f0200020002000200ffff0900000000000000000000000000000000000028",
1299 "00502e0a0002000001158007fff0000100010000000000800000070000010000000000000000000000000028",
1300 "00512e0a0002000001158007000f0200020002000200ffff0900000000000000000000000000000000000028",
1301 "00522e0a0002000001158008fff0000100010000000000800100000000010000000000000000000000000028",
1302 "00532e0a0002000001158008000f0200020002000200ffff0900000000000000000000000000000000000028",
1303 "00542e0a0002000001158009fff0000100010000000000800100010000010000000000000000000000000028",
1304 "00552e0a0002000001158009000f0200020002000200ffff0900000000000000000000000000000000000028",
1305 "00562e0a000200000115800afff0000100010000000000800100020000010000000000000000000000000028",
1306 "00572e0a000200000115800a000f0200020002000200ffff0900000000000000000000000000000000000028",
1307 "00582e0a000200000115800bfff0000100010000000000800100030000010000000000000000000000000028",
1308 "00592e0a000200000115800b000f0200020002000200ffff0900000000000000000000000000000000000028",
1309 "005a2e0a000200000115800cfff0000100010000000000800100040000010000000000000000000000000028",
1310 "005b2e0a000200000115800c000f0200020002000200ffff0900000000000000000000000000000000000028",
1311 "005c2e0a000200000115800dfff0000100010000000000800100050000010000000000000000000000000028",
1312 "005d2e0a000200000115800d000f0200020002000200ffff0900000000000000000000000000000000000028",
1313 "005e2e0a000200000115800efff0000100010000000000800100060000010000000000000000000000000028",
1314 "005f2e0a000200000115800e000f0200020002000200ffff0900000000000000000000000000000000000028",
1315 "00602e0a000200000115800ffff0000100010000000000800100070000010000000000000000000000000028",
1316 "00612e0a000200000115800f000f0200020002000200ffff0900000000000000000000000000000000000028",
1317 "00622e0a0002000001158010fff0000100010000000000800200000000010000000000000000000000000028",
1318 "00632e0a0002000001158010000f0200020002000200ffff0900000000000000000000000000000000000028",
1319 "00642e0a0002000001158011fff0000100010000000000800200010000010000000000000000000000000028",
1320 "00652e0a0002000001158011000f0200020002000200ffff0900000000000000000000000000000000000028",
1321 "00662e0a0002000001158012fff0000100010000000000800200020000010000000000000000000000000028",
1322 "00672e0a0002000001158012000f0200020002000200ffff0900000000000000000000000000000000000028",
1323 "00682e0a0002000001158013fff0000100010000000000800200030000010000000000000000000000000028",
1324 "00692e0a0002000001158013000f0200020002000200ffff0900000000000000000000000000000000000028",
1325 "006a2e0a0002000001158014fff0000100010000000000800200040000010000000000000000000000000028",
1326 "006b2e0a0002000001158014000f0200020002000200ffff0900000000000000000000000000000000000028",
1327 "006c2e0a0002000001158015fff0000100010000000000800200050000010000000000000000000000000028",
1328 "006d2e0a0002000001158015000f0200020002000200ffff0900000000000000000000000000000000000028",
1329 "006e2e0a0002000001158016fff0000100010000000000800200060000010000000000000000000000000028",
1330 "006f2e0a0002000001158016000f0200020002000200ffff0900000000000000000000000000000000000028",
1331 "00702e0a0002000001158017fff0000100010000000000800200070000010000000000000000000000000028",
1332 "00712e0a0002000001158017000f0200020002000200ffff0900000000000000000000000000000000000028",
1333 "00722e0a0002000001158018fff0000100010000000000800300000000010000000000000000000000000028",
1334 "00732e0a0002000001158018000f0200020002000200ffff0900000000000000000000000000000000000028",
1335 "00742e0a0002000001158019fff0000100010000000000800300010000010000000000000000000000000028",
1336 "00752e0a0002000001158019000f0200020002000200ffff0900000000000000000000000000000000000028",
1337 "00762e0a000200000115801afff0000100010000000000800300020000010000000000000000000000000028",
1338 "00772e0a000200000115801a000f0200020002000200ffff0900000000000000000000000000000000000028",
1339 "00782e0a000200000115801bfff0000100010000000000800300030000010000000000000000000000000028",
1340 "00792e0a000200000115801b000f0200020002000200ffff0900000000000000000000000000000000000028",
1341 "007a2e0a000200000115801cfff0000100010000000000800300040000010000000000000000000000000028",
1342 "007b2e0a000200000115801c000f0200020002000200ffff0900000000000000000000000000000000000028",
1343 "007c2e0a000200000115801dfff0000100010000000000800300050000010000000000000000000000000028",
1344 "007d2e0a000200000115801d000f0200020002000200ffff0900000000000000000000000000000000000028",
1345 "007e2e0a000200000115801efff0000100010000000000800300060000010000000000000000000000000028",
1346 "007f2e0a000200000115801e000f0200020002000200ffff0900000000000000000000000000000000000028",
1347 "00802e0a000200000115801ffff0000100010000000000800300070000010000000000000000000000000028",
1348 "00812e0a000200000115801f000f0200020002000200ffff0900000000000000000000000000000000000028",
1349 "00822e0a0002000001158020fff0000100010000000000800400000000010000000000000000000000000028",
1350 "00832e0a0002000001158020000f0200020002000200ffff0900000000000000000000000000000000000028",
1351 "00842e0a0002000001158021fff0000100010000000000800400010000010000000000000000000000000028",
1352 "00852e0a0002000001158021000f0200020002000200ffff0900000000000000000000000000000000000028",
1353 "00862e0a0002000001158022fff0000100010000000000800400020000010000000000000000000000000028",
1354 "00872e0a0002000001158022000f0200020002000200ffff0900000000000000000000000000000000000028",
1355 "00882e0a0002000001158023fff0000100010000000000800400030000010000000000000000000000000028",
1356 "00892e0a0002000001158023000f0200020002000200ffff0900000000000000000000000000000000000028",
1357 "008a2e0a0002000001158024fff0000100010000000000800400040000010000000000000000000000000028",
1358 "008b2e0a0002000001158024000f0200020002000200ffff0900000000000000000000000000000000000028",
1359 "008c2e0a0002000001158025fff0000100010000000000800400050000010000000000000000000000000028",
1360 "008d2e0a0002000001158025000f0200020002000200ffff0900000000000000000000000000000000000028",
1361 "008e2e0a0002000001158026fff0000100010000000000800400060000010000000000000000000000000028",
1362 "008f2e0a0002000001158026000f0200020002000200ffff0900000000000000000000000000000000000028",
1363 "00902e0a0002000001158027fff0000100010000000000800400070000010000000000000000000000000028",
1364 "00912e0a0002000001158027000f0200020002000200ffff0900000000000000000000000000000000000028",
1365 "00922e0a0002000001158028fff0000100010000000000800500000000010000000000000000000000000028",
1366 "00932e0a0002000001158028000f0200020002000200ffff0900000000000000000000000000000000000028",
1367 "00942e0a0002000001158029fff0000100010000000000800500010000010000000000000000000000000028",
1368 "00952e0a0002000001158029000f0200020002000200ffff0900000000000000000000000000000000000028",
1369 "00962e0a000200000115802afff0000100010000000000800500020000010000000000000000000000000028",
1370 "00972e0a000200000115802a000f0200020002000200ffff0900000000000000000000000000000000000028",
1371 "00982e0a000200000115802bfff0000100010000000000800500030000010000000000000000000000000028",
1372 "00992e0a000200000115802b000f0200020002000200ffff0900000000000000000000000000000000000028",
1373 "009a2e0a000200000115802cfff0000100010000000000800500040000010000000000000000000000000028",
1374 "009b2e0a000200000115802c000f0200020002000200ffff0900000000000000000000000000000000000028",
1375 "009c2e0a000200000115802dfff0000100010000000000800500050000010000000000000000000000000028",
1376 "009d2e0a000200000115802d000f0200020002000200ffff0900000000000000000000000000000000000028",
1377 "009e2e0a000200000115802efff0000100010000000000800500060000010000000000000000000000000028",
1378 "009f2e0a000200000115802e000f0200020002000200ffff0900000000000000000000000000000000000028",
1379 "00a02e0a000200000115802ffff0000100010000000000800500070000010000000000000000000000000028",
1380 "00a12e0a000200000115802f000f0200020002000200ffff0900000000000000000000000000000000000028",
1381 "00a22e0a0002000001158030fff0000100010000000000800600000000010000000000000000000000000028",
1382 "00a32e0a0002000001158030000f0200020002000200ffff0900000000000000000000000000000000000028",
1383 "00a42e0a0002000001158031fff0000100010000000000800600010000010000000000000000000000000028",
1384 "00a52e0a0002000001158031000f0200020002000200ffff0900000000000000000000000000000000000028",
1385 "00a62e0a0002000001158032fff0000100010000000000800600020000010000000000000000000000000028",
1386 "00a72e0a0002000001158032000f0200020002000200ffff0900000000000000000000000000000000000028",
1387 "00a82e0a0002000001158033fff0000100010000000000800600030000010000000000000000000000000028",
1388 "00a92e0a0002000001158033000f0200020002000200ffff0900000000000000000000000000000000000028",
1389 "00aa2e0a0002000001158034fff0000100010000000000800600040000010000000000000000000000000028",
1390 "00ab2e0a0002000001158034000f0200020002000200ffff0900000000000000000000000000000000000028",
1391 "00ac2e0a0002000001158035fff0000100010000000000800600050000010000000000000000000000000028",
1392 "00ad2e0a0002000001158035000f0200020002000200ffff0900000000000000000000000000000000000028",
1393 "00ae2e0a0002000001158036fff0000100010000000000800600060000010000000000000000000000000028",
1394 "00af2e0a0002000001158036000f0200020002000200ffff0900000000000000000000000000000000000028",
1395 "00b02e0a0002000001158037fff0000100010000000000800600070000010000000000000000000000000028",
1396 "00b12e0a0002000001158037000f0200020002000200ffff0900000000000000000000000000000000000028",
1397 "00b22e0a0002000001158038fff0000100010000000000800700000000010000000000000000000000000028",
1398 "00b32e0a0002000001158038000f0200020002000200ffff0900000000000000000000000000000000000028",
1399 "00b42e0a0002000001158039fff0000100010000000000800700010000010000000000000000000000000028",
1400 "00b52e0a0002000001158039000f0200020002000200ffff0900000000000000000000000000000000000028",
1401 "00b62e0a000200000115803afff0000100010000000000800700020000010000000000000000000000000028",
1402 "00b72e0a000200000115803a000f0200020002000200ffff0900000000000000000000000000000000000028",
1403 "00b82e0a000200000115803bfff0000100010000000000800700030000010000000000000000000000000028",
1404 "00b92e0a000200000115803b000f0200020002000200ffff0900000000000000000000000000000000000028",
1405 "00ba2e0a000200000115803cfff0000100010000000000800700040000010000000000000000000000000028",
1406 "00bb2e0a000200000115803c000f0200020002000200ffff0900000000000000000000000000000000000028",
1407 "00bc2e0a000200000115803dfff0000100010000000000800700050000010000000000000000000000000028",
1408 "00bd2e0a000200000115803d000f0200020002000200ffff0900000000000000000000000000000000000028",
1409 "00be2e0a000200000115803efff0000100010000000000800700060000010000000000000000000000000028",
1410 "00bf2e0a000200000115803e000f0200020002000200ffff0900000000000000000000000000000000000028",
1411 "00c02e0a000200000115803ffff0000100010000000000800700070000010000000000000000000000000028",
1412 "00c12e0a000200000115803f000f0200020002000200ffff0900000000000000000000000000000000000028",
1413 "00c22e0a0002000001168000f000800000000200000000000000000000000000000000000000000000000028",
1414 "00c32e0a0002000001168001f000800000000200000000000000000000000000000000000000000000000028",
1415 "00c42e0a0002000001168002f000800000000200000000000000000000000000000000000000000000000028",
1416 "00c52e0a0002000001168003f000800000000200000000000000000000000000000000000000000000000028",
1417 "00c62e0a0002000001168004f000800000000200000000000000000000000000000000000000000000000028",
1418 "00c72e0a0002000001168005f000800000000200000000000000000000000000000000000000000000000028",
1419 "00c82e0a0002000001168006f000800000000200000000000000000000000000000000000000000000000028",
1420 "00c92e0a0002000001168007f000800000000200000000000000000000000000000000000000000000000028",
1421 "00ca2e0a0002000001168008f000800100000200000000000000000000000000000000000000000000000028",
1422 "00cb2e0a0002000001168009f000800100000200000000000000000000000000000000000000000000000028",
1423 "00cc2e0a000200000116800af000800100000200000000000000000000000000000000000000000000000028",
1424 "00cd2e0a000200000116800bf000800100000200000000000000000000000000000000000000000000000028",
1425 "00ce2e0a000200000116800cf000800100000200000000000000000000000000000000000000000000000028",
1426 "00cf2e0a000200000116800df000800100000200000000000000000000000000000000000000000000000028",
1427 "00d02e0a000200000116800ef000800100000200000000000000000000000000000000000000000000000028",
1428 "00d12e0a000200000116800ff000800100000200000000000000000000000000000000000000000000000028",
1429 "00d22e0a0002000001168010f000800200000200000000000000000000000000000000000000000000000028",
1430 "00d32e0a0002000001168011f000800200000200000000000000000000000000000000000000000000000028",
1431 "00d42e0a0002000001168012f000800200000200000000000000000000000000000000000000000000000028",
1432 "00d52e0a0002000001168013f000800200000200000000000000000000000000000000000000000000000028",
1433 "00d62e0a0002000001168014f000800200000200000000000000000000000000000000000000000000000028",
1434 "00d72e0a0002000001168015f000800200000200000000000000000000000000000000000000000000000028",
1435 "00d82e0a0002000001168016f000800200000200000000000000000000000000000000000000000000000028",
1436 "00d92e0a0002000001168017f000800200000200000000000000000000000000000000000000000000000028",
1437 "00da2e0a0002000001168018f000800300000200000000000000000000000000000000000000000000000028",
1438 "00db2e0a0002000001168019f000800300000200000000000000000000000000000000000000000000000028",
1439 "00dc2e0a000200000116801af000800300000200000000000000000000000000000000000000000000000028",
1440 "00dd2e0a000200000116801bf000800300000200000000000000000000000000000000000000000000000028",
1441 "00de2e0a000200000116801cf000800300000200000000000000000000000000000000000000000000000028",
1442 "00df2e0a000200000116801df000800300000200000000000000000000000000000000000000000000000028",
1443 "00e02e0a000200000116801ef000800300000200000000000000000000000000000000000000000000000028",
1444 "00e12e0a000200000116801ff000800300000200000000000000000000000000000000000000000000000028",
1445 "00e22e0a0002000001168020f000800400000200000000000000000000000000000000000000000000000028",
1446 "00e32e0a0002000001168021f000800400000200000000000000000000000000000000000000000000000028",
1447 "00e42e0a0002000001168022f000800400000200000000000000000000000000000000000000000000000028",
1448 "00e52e0a0002000001168023f000800400000200000000000000000000000000000000000000000000000028",
1449 "00e62e0a0002000001168024f000800400000200000000000000000000000000000000000000000000000028",
1450 "00e72e0a0002000001168025f000800400000200000000000000000000000000000000000000000000000028",
1451 "00e82e0a0002000001168026f000800400000200000000000000000000000000000000000000000000000028",
1452 "00e92e0a0002000001168027f000800400000200000000000000000000000000000000000000000000000028",
1453 "00ea2e0a0002000001168028f000800500000200000000000000000000000000000000000000000000000028",
1454 "00eb2e0a0002000001168029f000800500000200000000000000000000000000000000000000000000000028",
1455 "00ec2e0a000200000116802af000800500000200000000000000000000000000000000000000000000000028",
1456 "00ed2e0a000200000116802bf000800500000200000000000000000000000000000000000000000000000028",
1457 "00ee2e0a000200000116802cf000800500000200000000000000000000000000000000000000000000000028",
1458 "00ef2e0a000200000116802df000800500000200000000000000000000000000000000000000000000000028",
1459 "00f02e0a000200000116802ef000800500000200000000000000000000000000000000000000000000000028",
1460 "00f12e0a000200000116802ff000800500000200000000000000000000000000000000000000000000000028",
1461 "00f22e0a0002000001168030f000800600000200000000000000000000000000000000000000000000000028",
1462 "00f32e0a0002000001168031f000800600000200000000000000000000000000000000000000000000000028",
1463 "00f42e0a0002000001168032f000800600000200000000000000000000000000000000000000000000000028",
1464 "00f52e0a0002000001168033f000800600000200000000000000000000000000000000000000000000000028",
1465 "00f62e0a0002000001168034f000800600000200000000000000000000000000000000000000000000000028",
1466 "00f72e0a0002000001168035f000800600000200000000000000000000000000000000000000000000000028",
1467 "00f82e0a0002000001168036f000800600000200000000000000000000000000000000000000000000000028",
1468 "00f92e0a0002000001168037f000800600000200000000000000000000000000000000000000000000000028",
1469 "00fa2e0a0002000001168038f000800700000200000000000000000000000000000000000000000000000028",
1470 "00fb2e0a0002000001168039f000800700000200000000000000000000000000000000000000000000000028",
1471 "00fc2e0a000200000116803af000800700000200000000000000000000000000000000000000000000000028",
1472 "00fd2e0a000200000116803bf000800700000200000000000000000000000000000000000000000000000028",
1473 "00fe2e0a000200000116803cf000800700000200000000000000000000000000000000000000000000000028",
1474 "00ff2e0a000200000116803df000800700000200000000000000000000000000000000000000000000000028",
1475 "01002e0a000200000116803ef000800700000200000000000000000000000000000000000000000000000028",
1476 "01012e0a000200000116803ff000800700000200000000000000000000000000000000000000000000000028",
1477 "01022e0a0002000001490401c000000000000000000000000000000000000000000000000000000000000028",
1478 "01032e0a00020000014904012000000000000000000000000000000000000000000000000000000000000028",
1479 "01042e0a00020000014904011800ffffffff0000000000000000000000000000000000000000000000000028",
1480 }
1481 firstTid := uint16(3)
1482
1483 for _, packetString := range mibUploadNextSequence {
1484 data, err := stringToPacket(packetString)
1485 assert.NoError(t, err)
1486
1487 packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.NoCopy)
1488 assert.NotNil(t, packet)
1489
1490 omciLayer := packet.Layer(LayerTypeOMCI)
1491 assert.NotNil(t, omciLayer)
1492
1493 omciMsg, ok := omciLayer.(*OMCI)
1494 assert.True(t, ok)
1495 assert.Equal(t, firstTid, omciMsg.TransactionID)
1496 assert.Equal(t, MibUploadNextResponseType, omciMsg.MessageType)
1497 assert.Equal(t, uint16(40), omciMsg.Length)
1498
1499 msgLayer := packet.Layer(LayerTypeMibUploadNextResponse)
1500 assert.NotNil(t, msgLayer)
1501
1502 uploadResponse, ok2 := msgLayer.(*MibUploadNextResponse)
1503 assert.True(t, ok2)
1504 assert.Equal(t, me.OnuDataClassID, uploadResponse.EntityClass)
1505 assert.Equal(t, uint16(0), uploadResponse.EntityInstance)
1506
1507 // Test serialization back to former string
1508 var options gopacket.SerializeOptions
1509 options.FixLengths = true
1510
1511 buffer := gopacket.NewSerializeBuffer()
1512 err = gopacket.SerializeLayers(buffer, options, omciMsg, uploadResponse)
1513 assert.NoError(t, err)
1514
1515 outgoingPacket := buffer.Bytes()
1516 reconstituted := packetToString(outgoingPacket)
1517 assert.Equal(t, strings.ToLower(packetString), reconstituted)
1518
1519 // Advance TID
1520 firstTid += 1
1521 }
1522}
1523
1524// TestUnsupportedG988ClassIDMibUploadNextResponse tests decoding of an Unknown class ID that is
1525// in the range of IDs assigned for G.988 use
1526func TestUnsupportedG988ClassIDMibUploadNextResponse(t *testing.T) {
1527 // The unsupported G.988 class ID below is 37 (0x0025), which is marked in the G.988
1528 // (11/2017) as 'Intentionally left blank). The encoded frame is a Get-Next
1529 // response with a single attribute 1 & 16 (0x8001) encoded.
1530 //
1531 tid := 3
1532 cid := 0x25
1533 eid := 1
1534 mask := 0x8000
1535 omci_hdr := "00032e0a"
1536 msg_hdr := "00020000"
1537 reported_me_hdr := "002500018000"
1538 attr := "0102030405060708090A0B0C0D0E0F101112131415161718191A"
1539 trailer := "0000002828ce00e2"
1540 msg := omci_hdr + msg_hdr + reported_me_hdr + attr + trailer
1541 data, err := stringToPacket(msg)
1542 assert.NoError(t, err)
1543
1544 // Decode packet (lazy this time)
1545 packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.Lazy)
1546 assert.NotNil(t, packet)
1547
1548 // OMCI Layer Contents are the
1549 // - TCI (2 bytes)
1550 // - Msg Type (1 byte)
1551 // - Device Ident (1 byte)
1552 //
1553 // payload is remaining layers (less optional length and MIC)
1554
1555 omciLayer := packet.Layer(LayerTypeOMCI)
1556 assert.NotNil(t, packet)
1557
1558 contents := omciLayer.LayerContents()
1559 payload := omciLayer.LayerPayload()
1560 assert.NotNil(t, contents)
1561 assert.NotNil(t, payload)
1562 assert.Equal(t, len(contents), len(omci_hdr)/2)
1563 assert.Equal(t, len(payload), len(msg_hdr+reported_me_hdr+attr)/2)
1564
1565 omciMsg, ok := omciLayer.(*OMCI)
1566 assert.True(t, ok)
1567 assert.Equal(t, uint16(tid), omciMsg.TransactionID)
1568 assert.Equal(t, MibUploadNextResponseType, omciMsg.MessageType)
1569 assert.Equal(t, uint16(40), omciMsg.Length)
1570
1571 // Message Layer contents for a MIB upload next response (baseline message set) are the
1572 // - OMCI Message Header (TCI, msg Type, ...) (4 bytes)
1573 //
1574 // Message Layer payload for a MIB upload next response are the
1575 // - ONU Data Class/Instance (4 bytes)
1576 // - Reported Managed Entity Class/Instance (4 bytes)
1577 // - Attribute Mask (2 bytes)
1578 // - Attributes
1579 // and zero-padding (but not length & MIC)
1580
1581 msgLayer := packet.Layer(LayerTypeMibUploadNextResponse)
1582 assert.NotNil(t, msgLayer)
1583
1584 contents = msgLayer.LayerContents()
1585 payload = msgLayer.LayerPayload()
1586 assert.NotNil(t, contents)
1587 assert.NotNil(t, payload)
1588 assert.Equal(t, len(msg_hdr)/2, len(contents))
1589 assert.Equal(t, len(reported_me_hdr+attr)/2, len(payload))
1590
1591 uploadResponse, ok2 := msgLayer.(*MibUploadNextResponse)
1592 assert.True(t, ok2)
1593 assert.NotNil(t, uploadResponse)
1594
1595 assert.Equal(t, me.OnuDataClassID, uploadResponse.EntityClass)
1596 assert.Equal(t, uint16(0), uploadResponse.EntityInstance)
1597 assert.Equal(t, me.ClassID(cid), uploadResponse.ReportedME.GetClassID())
1598 assert.Equal(t, uint16(eid), uploadResponse.ReportedME.GetEntityID())
1599 assert.Equal(t, uint16(mask), uploadResponse.ReportedME.GetAttributeMask())
1600
1601 name := "UnknownAttr_1"
1602 blobAttribute, err := uploadResponse.ReportedME.GetAttribute(name)
1603 assert.Nil(t, err)
1604 assert.NotNil(t, blobAttribute)
1605}
1606
1607func TestUnsupportedG988ClassIDMibUploadNextResponseAttributes(t *testing.T) {
1608 // Same as previous, but try different attribute mask combinations
1609 tid := 3
1610 cid := 0x25
1611 eid := 1
1612
1613 // There are a number of ranges for vendor ID use. List below picks one from
1614 // each of those ranges
1615 masks := []uint16{0x8001, 0x0000, 0x0001, 0x8000}
1616
1617 trailer := "0000002828ce00e2"
1618 attr := "0102030405060708090A0B0C0D0E0F101112131415161718191A"
1619
1620 for _, mask := range masks {
1621 hdr := fmt.Sprintf("00032e0a0002000000250001%04x", mask)
1622
1623 msg := hdr + attr + trailer
1624 data, err := stringToPacket(msg)
1625 assert.NoError(t, err)
1626
1627 packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.NoCopy)
1628 assert.NotNil(t, packet)
1629
1630 omciLayer := packet.Layer(LayerTypeOMCI)
1631 assert.NotNil(t, packet)
1632
1633 omciMsg, ok := omciLayer.(*OMCI)
1634 assert.True(t, ok)
1635 assert.Equal(t, uint16(tid), omciMsg.TransactionID)
1636 assert.Equal(t, MibUploadNextResponseType, omciMsg.MessageType)
1637 assert.Equal(t, uint16(40), omciMsg.Length)
1638
1639 msgLayer := packet.Layer(LayerTypeMibUploadNextResponse)
1640 assert.NotNil(t, msgLayer)
1641
1642 uploadResponse, ok2 := msgLayer.(*MibUploadNextResponse)
1643 assert.True(t, ok2)
1644 assert.NotNil(t, uploadResponse)
1645 assert.Equal(t, me.OnuDataClassID, uploadResponse.EntityClass)
1646 assert.Equal(t, uint16(0), uploadResponse.EntityInstance)
1647 assert.Equal(t, me.ClassID(cid), uploadResponse.ReportedME.GetClassID())
1648 assert.Equal(t, uint16(eid), uploadResponse.ReportedME.GetEntityID())
1649 assert.Equal(t, mask, uploadResponse.ReportedME.GetAttributeMask())
1650 }
1651}
1652
1653// TestUnsupportedVendorClassIDMibUploadNextResponse tests decoding of an Unknown class ID that is
1654// in the range of IDs assigned for vendor assignment
1655func TestUnsupportedVendorClassIDMibUploadNextResponse(t *testing.T) {
1656 tid := 3
1657 eid := 0
1658 mask := 0x8000
1659
1660 // There are a number of ranges for vendor ID use. List below picks one from
1661 // each of those ranges
1662 classIDs := []uint16{250, 355, 65500}
1663
1664 hdr := "00032e0a00020000"
1665 attr := "0102030405060708090A0B0C0D0E0F101112131415161718191A"
1666 trailer := "0000002828ce00e2"
1667
1668 for _, cid := range classIDs {
1669 cidToMask := fmt.Sprintf("%04x%04x%04x", cid, eid, mask)
1670 msg := hdr + cidToMask + attr + trailer
1671 data, err := stringToPacket(msg)
1672 assert.NoError(t, err)
1673
1674 packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.NoCopy)
1675 assert.NotNil(t, packet)
1676
1677 omciLayer := packet.Layer(LayerTypeOMCI)
1678 assert.NotNil(t, packet)
1679
1680 omciMsg, ok := omciLayer.(*OMCI)
1681 assert.True(t, ok)
1682 assert.Equal(t, uint16(tid), omciMsg.TransactionID)
1683 assert.Equal(t, MibUploadNextResponseType, omciMsg.MessageType)
1684 assert.Equal(t, uint16(40), omciMsg.Length)
1685
1686 msgLayer := packet.Layer(LayerTypeMibUploadNextResponse)
1687 assert.NotNil(t, msgLayer)
1688
1689 uploadResponse, ok2 := msgLayer.(*MibUploadNextResponse)
1690 assert.True(t, ok2)
1691 assert.NotNil(t, uploadResponse)
1692 assert.Equal(t, me.OnuDataClassID, uploadResponse.EntityClass)
1693 assert.Equal(t, uint16(0), uploadResponse.EntityInstance)
1694 assert.Equal(t, me.ClassID(cid), uploadResponse.ReportedME.GetClassID())
1695 assert.Equal(t, uint16(eid), uploadResponse.ReportedME.GetEntityID())
1696 assert.Equal(t, uint16(mask), uploadResponse.ReportedME.GetAttributeMask())
1697
1698 name := "UnknownAttr_1"
1699 blobAttribute, err := uploadResponse.ReportedME.GetAttribute(name)
1700
1701 assert.Nil(t, err)
1702 assert.NotNil(t, blobAttribute)
1703
1704 byteValue, ok3 := blobAttribute.([]uint8)
1705 assert.True(t, ok3)
1706 assert.NotNil(t, byteValue)
1707 }
1708}
1709
1710func TestMibUpload(t *testing.T) {
1711 mibUpload := "00304D0A000200000000000000000000" +
1712 "00000000000000000000000000000000" +
1713 "000000000000000000000028"
1714
1715 data, err := stringToPacket(mibUpload)
1716 assert.NoError(t, err)
1717
1718 packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.NoCopy)
1719 assert.NotNil(t, packet)
1720
1721 omciLayer := packet.Layer(LayerTypeOMCI)
1722 assert.NotNil(t, packet)
1723
1724 omciMsg, ok := omciLayer.(*OMCI)
1725 assert.True(t, ok)
1726 assert.Equal(t, uint16(0x30), omciMsg.TransactionID)
1727 assert.Equal(t, MibUploadRequestType, omciMsg.MessageType)
1728 assert.Equal(t, uint16(40), omciMsg.Length)
1729
1730 msgLayer := packet.Layer(LayerTypeMibUploadRequest)
1731 assert.NotNil(t, msgLayer)
1732
1733 uploadRequest, ok2 := msgLayer.(*MibUploadRequest)
1734 assert.True(t, ok2)
1735 assert.Equal(t, me.OnuDataClassID, uploadRequest.EntityClass)
1736 assert.Equal(t, uint16(0), uploadRequest.EntityInstance)
1737
1738 // Test serialization back to former string
1739 var options gopacket.SerializeOptions
1740 options.FixLengths = true
1741
1742 buffer := gopacket.NewSerializeBuffer()
1743 err = gopacket.SerializeLayers(buffer, options, omciMsg, uploadRequest)
1744 assert.NoError(t, err)
1745
1746 outgoingPacket := buffer.Bytes()
1747 reconstituted := packetToString(outgoingPacket)
1748 assert.Equal(t, strings.ToLower(mibUpload), reconstituted)
1749}