From 27ac295edba2974a2fe0333717177608ffa4cdb2 Mon Sep 17 00:00:00 2001 From: Yoshiyuki Kurauchi Date: Wed, 28 Oct 2020 22:14:05 +0900 Subject: [PATCH 1/9] Fix decoding of DLBufferingDuration IE --- ie/dl-buffering-duration.go | 23 +++++++++++------------ 1 file changed, 11 insertions(+), 12 deletions(-) diff --git a/ie/dl-buffering-duration.go b/ie/dl-buffering-duration.go index 82ecc23d..feb912b3 100644 --- a/ie/dl-buffering-duration.go +++ b/ie/dl-buffering-duration.go @@ -60,23 +60,22 @@ func (i *IE) DLBufferingDuration() (time.Duration, error) { switch i.Type { case DLBufferingDuration: var d time.Duration - switch i.Payload[0] | 0xe0 { - case 0xe0: + switch (i.Payload[0] & 0xe0) >> 5 { + case 0x07: d = time.Duration(math.MaxInt64) - case 0x80: - d = time.Duration(i.Payload[0]|0x1f) * 10 * time.Hour - case 0x60: - d = time.Duration(i.Payload[0]|0x1f) * time.Hour - case 0x40: - d = time.Duration(i.Payload[0]|0x1f) * 10 * time.Minute - case 0x20: - d = time.Duration(i.Payload[0]|0x1f) * time.Minute + case 0x04: + d = time.Duration(i.Payload[0]&0x1f) * 10 * time.Hour + case 0x03: + d = time.Duration(i.Payload[0]&0x1f) * time.Hour + case 0x02: + d = time.Duration(i.Payload[0]&0x1f) * 10 * time.Minute + case 0x01: + d = time.Duration(i.Payload[0]&0x1f) * time.Minute case 0x00: - d = time.Duration(i.Payload[0]|0x1f) * 2 * time.Second + d = time.Duration(i.Payload[0]&0x1f) * 2 * time.Second default: d = 0 } - return d, nil case UpdateBARWithinSessionReportResponse: ies, err := i.CreateBAR() From 1fe024751da707116794edbdbe0e217a51d120a3 Mon Sep 17 00:00:00 2001 From: Yoshiyuki Kurauchi Date: Wed, 28 Oct 2020 22:14:18 +0900 Subject: [PATCH 2/9] Fix decoding of GracefulReleasePeriod IE --- ie/graceful-release-period.go | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/ie/graceful-release-period.go b/ie/graceful-release-period.go index c643a84a..26288d33 100644 --- a/ie/graceful-release-period.go +++ b/ie/graceful-release-period.go @@ -61,19 +61,19 @@ func (i *IE) GracefulReleasePeriod() (time.Duration, error) { } var d time.Duration - switch i.Payload[0] | 0xe0 { - case 0xe0: + switch (i.Payload[0] & 0xe0) >> 5 { + case 0x07: d = time.Duration(math.MaxInt64) - case 0x80: - d = time.Duration(i.Payload[0]|0x1f) * 10 * time.Hour - case 0x60: - d = time.Duration(i.Payload[0]|0x1f) * time.Hour - case 0x40: - d = time.Duration(i.Payload[0]|0x1f) * 10 * time.Minute - case 0x20: - d = time.Duration(i.Payload[0]|0x1f) * time.Minute + case 0x04: + d = time.Duration(i.Payload[0]&0x1f) * 10 * time.Hour + case 0x03: + d = time.Duration(i.Payload[0]&0x1f) * time.Hour + case 0x02: + d = time.Duration(i.Payload[0]&0x1f) * 10 * time.Minute + case 0x01: + d = time.Duration(i.Payload[0]&0x1f) * time.Minute case 0x00: - d = time.Duration(i.Payload[0]|0x1f) * 2 * time.Second + d = time.Duration(i.Payload[0]&0x1f) * 2 * time.Second default: d = 0 } From d57864fb564d8122aa116468c90a2db2cf00a81f Mon Sep 17 00:00:00 2001 From: Yoshiyuki Kurauchi Date: Wed, 28 Oct 2020 22:18:02 +0900 Subject: [PATCH 3/9] Add tests for methods that return time.Duration values --- ie/ie_duration_test.go | 147 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 147 insertions(+) create mode 100644 ie/ie_duration_test.go diff --git a/ie/ie_duration_test.go b/ie/ie_duration_test.go new file mode 100644 index 00000000..799c71f5 --- /dev/null +++ b/ie/ie_duration_test.go @@ -0,0 +1,147 @@ +// Copyright 2019-2020 go-pfcp authors. All rights reserved. +// Use of this source code is governed by a MIT-style license that can be +// found in the LICENSE file. + +package ie_test + +import ( + "testing" + "time" + + "github.com/google/go-cmp/cmp" + "github.com/wmnsk/go-pfcp/ie" +) + +func TestDurationIEs(t *testing.T) { + cases := []struct { + description string + structured *ie.IE + decoded time.Duration + decoderFunc func(*ie.IE) (time.Duration, error) + }{ + { + description: "AveragePacketDelay", + structured: ie.NewAveragePacketDelay(10 * time.Second), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.AveragePacketDelay() }, + }, { + description: "DLBufferingDuration/20hr", + structured: ie.NewDLBufferingDuration(20 * time.Hour), + decoded: 20 * time.Hour, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.DLBufferingDuration() }, + }, { + description: "DLBufferingDuration/15min", + structured: ie.NewDLBufferingDuration(15 * time.Minute), + decoded: 15 * time.Minute, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.DLBufferingDuration() }, + }, { + description: "DLBufferingDuration/30sec", + structured: ie.NewDLBufferingDuration(30 * time.Second), + decoded: 30 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.DLBufferingDuration() }, + }, { + description: "DownlinkDataNotificationDelay", + structured: ie.NewDownlinkDataNotificationDelay(100 * time.Millisecond), + decoded: 100 * time.Millisecond, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.DownlinkDataNotificationDelay() }, + }, { + description: "DurationMeasurement", + structured: ie.NewDurationMeasurement(10 * time.Second), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.DurationMeasurement() }, + }, { + description: "EthernetInactivityTimer", + structured: ie.NewEthernetInactivityTimer(10 * time.Second), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.EthernetInactivityTimer() }, + }, { + description: "GracefulReleasePeriod/20hr", + structured: ie.NewGracefulReleasePeriod(20 * time.Hour), + decoded: 20 * time.Hour, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.GracefulReleasePeriod() }, + }, { + description: "GracefulReleasePeriod/15min", + structured: ie.NewGracefulReleasePeriod(15 * time.Minute), + decoded: 15 * time.Minute, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.GracefulReleasePeriod() }, + }, { + description: "GracefulReleasePeriod/30sec", + structured: ie.NewGracefulReleasePeriod(30 * time.Second), + decoded: 30 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.GracefulReleasePeriod() }, + }, { + description: "MaximumPacketDelay", + structured: ie.NewMaximumPacketDelay(10 * time.Second), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.MaximumPacketDelay() }, + }, { + description: "MinimumPacketDelay", + structured: ie.NewMinimumPacketDelay(10 * time.Second), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.MinimumPacketDelay() }, + }, { + description: "MinimumWaitTime", + structured: ie.NewMinimumWaitTime(10 * time.Second), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.MinimumWaitTime() }, + }, { + description: "QuotaHoldingTime", + structured: ie.NewQuotaHoldingTime(10 * time.Second), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.QuotaHoldingTime() }, + }, { + description: "SubsequentTimeQuota", + structured: ie.NewSubsequentTimeQuota(10 * time.Second), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.SubsequentTimeQuota() }, + }, { + description: "TimeOffsetMeasurement", + structured: ie.NewTimeOffsetMeasurement(10 * time.Second), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.TimeOffsetMeasurement() }, + }, { + description: "TimeOffsetThreshold", + structured: ie.NewTimeOffsetThreshold(10 * time.Second), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.TimeOffsetThreshold() }, + }, { + description: "TimeQuota", + structured: ie.NewTimeQuota(10 * time.Second), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.TimeQuota() }, + }, { + description: "Timer/20hr", + structured: ie.NewTimer(20 * time.Hour), + decoded: 20 * time.Hour, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.Timer() }, + }, { + description: "Timer/15min", + structured: ie.NewTimer(15 * time.Minute), + decoded: 15 * time.Minute, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.Timer() }, + }, { + description: "Timer/30sec", + structured: ie.NewTimer(30 * time.Second), + decoded: 30 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.Timer() }, + }, { + description: "UserPlaneInactivityTimer", + structured: ie.NewUserPlaneInactivityTimer(10 * time.Second), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.UserPlaneInactivityTimer() }, + }, + } + + for _, c := range cases { + t.Run(c.description, func(t *testing.T) { + got, err := c.decoderFunc(c.structured) + if err != nil { + t.Fatal(err) + } + + if diff := cmp.Diff(got, c.decoded); diff != "" { + t.Error(diff) + } + }) + } +} From eecc84fd8465a22c9f8b66381bf7d99b757ccb1e Mon Sep 17 00:00:00 2001 From: Yoshiyuki Kurauchi Date: Wed, 28 Oct 2020 22:44:32 +0900 Subject: [PATCH 4/9] Fix decoding of AveragePacketDelay within GTPUPathQoSReport --- ie/average-packet-delay.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ie/average-packet-delay.go b/ie/average-packet-delay.go index df37f270..26c51b58 100644 --- a/ie/average-packet-delay.go +++ b/ie/average-packet-delay.go @@ -43,7 +43,7 @@ func (i *IE) AveragePacketDelay() (time.Duration, error) { return 0, err } for _, x := range ies { - if x.Type == QoSInformationInGTPUPathQoSReport { + if x.Type == AveragePacketDelay { return x.AveragePacketDelay() } } From e47710e92cbaff26efb5f63f2f9bef673ee973c4 Mon Sep 17 00:00:00 2001 From: Yoshiyuki Kurauchi Date: Wed, 28 Oct 2020 22:44:55 +0900 Subject: [PATCH 5/9] Fix decoding of DLBufferingDuration within UpdateBARWithinSessionReportResponse --- ie/dl-buffering-duration.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ie/dl-buffering-duration.go b/ie/dl-buffering-duration.go index feb912b3..c64a1adc 100644 --- a/ie/dl-buffering-duration.go +++ b/ie/dl-buffering-duration.go @@ -78,7 +78,7 @@ func (i *IE) DLBufferingDuration() (time.Duration, error) { } return d, nil case UpdateBARWithinSessionReportResponse: - ies, err := i.CreateBAR() + ies, err := i.UpdateBAR() if err != nil { return 0, err } From adcd04ea04cfa609516b8225791418a87c994ca2 Mon Sep 17 00:00:00 2001 From: Yoshiyuki Kurauchi Date: Wed, 28 Oct 2020 22:52:19 +0900 Subject: [PATCH 6/9] Let NewUpdateBARWithinSessionReportResponse take arbitrary number of IEs --- ie/update-bar.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ie/update-bar.go b/ie/update-bar.go index 63456abb..7d175f10 100644 --- a/ie/update-bar.go +++ b/ie/update-bar.go @@ -15,8 +15,8 @@ func NewUpdateBARWithinSessionModificationRequest(ies ...*IE) *IE { } // NewUpdateBARWithinSessionReportResponse creates a new UpdateBARWithinSessionReportResponse IE. -func NewUpdateBARWithinSessionReportResponse(bar, delay, duration, dlCount, bufCount *IE) *IE { - return NewUpdateBAR(UpdateBARWithinSessionReportResponse, bar, delay, duration, dlCount, bufCount) +func NewUpdateBARWithinSessionReportResponse(ies ...*IE) *IE { + return NewUpdateBAR(UpdateBARWithinSessionReportResponse, ies...) } // UpdateBAR returns the IEs above UpdateBAR if the type of IE matches. From f65313b9908889a6df31fcb7dbf8461ecb13ee32 Mon Sep 17 00:00:00 2001 From: Yoshiyuki Kurauchi Date: Wed, 28 Oct 2020 22:56:45 +0900 Subject: [PATCH 7/9] Fix decoding of MaximumPacketDelay within GTPUPathQoSReport --- ie/maximum-packet-delay.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ie/maximum-packet-delay.go b/ie/maximum-packet-delay.go index 73edfa96..3985f5b3 100644 --- a/ie/maximum-packet-delay.go +++ b/ie/maximum-packet-delay.go @@ -43,7 +43,7 @@ func (i *IE) MaximumPacketDelay() (time.Duration, error) { return 0, err } for _, x := range ies { - if x.Type == QoSInformationInGTPUPathQoSReport { + if x.Type == MaximumPacketDelay { return x.MaximumPacketDelay() } } From 87b69f7132e76d0fe82c4d0d3ec6c2ddb24f6de4 Mon Sep 17 00:00:00 2001 From: Yoshiyuki Kurauchi Date: Wed, 28 Oct 2020 22:57:00 +0900 Subject: [PATCH 8/9] Fix decoding of MinimumPacketDelay within GTPUPathQoSReport --- ie/minimum-packet-delay.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ie/minimum-packet-delay.go b/ie/minimum-packet-delay.go index 7dbec243..9776b12e 100644 --- a/ie/minimum-packet-delay.go +++ b/ie/minimum-packet-delay.go @@ -43,7 +43,7 @@ func (i *IE) MinimumPacketDelay() (time.Duration, error) { return 0, err } for _, x := range ies { - if x.Type == QoSInformationInGTPUPathQoSReport { + if x.Type == MinimumPacketDelay { return x.MinimumPacketDelay() } } From c7db18acf8a5e88dbe42d13cb8968c81e4ebb8a5 Mon Sep 17 00:00:00 2001 From: Yoshiyuki Kurauchi Date: Wed, 28 Oct 2020 23:04:36 +0900 Subject: [PATCH 9/9] Add tests for time.Duration-value IE within grouped IEs --- ie/ie_duration_test.go | 269 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 269 insertions(+) diff --git a/ie/ie_duration_test.go b/ie/ie_duration_test.go index 799c71f5..c5a6aa8e 100644 --- a/ie/ie_duration_test.go +++ b/ie/ie_duration_test.go @@ -24,6 +24,30 @@ func TestDurationIEs(t *testing.T) { structured: ie.NewAveragePacketDelay(10 * time.Second), decoded: 10 * time.Second, decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.AveragePacketDelay() }, + }, { + description: "AveragePacketDelay/GTPUPathQoSControlInformation", + structured: ie.NewGTPUPathQoSControlInformation( + ie.NewRemoteGTPUPeer(0x0e, "127.0.0.1", "", ie.DstInterfaceAccess, "some.instance.example"), + ie.NewAveragePacketDelay(10*time.Second), + ), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.AveragePacketDelay() }, + }, { + description: "AveragePacketDelay/GTPUPathQoSReport", + structured: ie.NewGTPUPathQoSReport( + ie.NewRemoteGTPUPeer(0x0e, "127.0.0.1", "", ie.DstInterfaceAccess, "some.instance.example"), + ie.NewAveragePacketDelay(10*time.Second), + ), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.AveragePacketDelay() }, + }, { + description: "AveragePacketDelay/QoSInformationInGTPUPathQoSReport", + structured: ie.NewQoSInformationInGTPUPathQoSReport( + ie.NewTransportLevelMarking(0x1111), + ie.NewAveragePacketDelay(10*time.Second), + ), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.AveragePacketDelay() }, }, { description: "DLBufferingDuration/20hr", structured: ie.NewDLBufferingDuration(20 * time.Hour), @@ -39,21 +63,93 @@ func TestDurationIEs(t *testing.T) { structured: ie.NewDLBufferingDuration(30 * time.Second), decoded: 30 * time.Second, decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.DLBufferingDuration() }, + }, { + description: "DLBufferingDuration/UpdateBARWithinSessionReportResponse", + structured: ie.NewUpdateBARWithinSessionReportResponse( + ie.NewBARID(0xff), + ie.NewDLBufferingDuration(30*time.Second), + ), + decoded: 30 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.DLBufferingDuration() }, }, { description: "DownlinkDataNotificationDelay", structured: ie.NewDownlinkDataNotificationDelay(100 * time.Millisecond), decoded: 100 * time.Millisecond, decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.DownlinkDataNotificationDelay() }, + }, { + description: "DownlinkDataNotificationDelay/CreateBAR", + structured: ie.NewCreateBAR( + ie.NewBARID(0xff), + ie.NewDownlinkDataNotificationDelay(100*time.Millisecond), + ), + decoded: 100 * time.Millisecond, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.DownlinkDataNotificationDelay() }, + }, { + description: "DownlinkDataNotificationDelay/UpdateBARWithinSessionReportResponse", + structured: ie.NewUpdateBARWithinSessionReportResponse( + ie.NewBARID(0xff), + ie.NewDownlinkDataNotificationDelay(100*time.Millisecond), + ), + decoded: 100 * time.Millisecond, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.DownlinkDataNotificationDelay() }, + }, { + description: "DownlinkDataNotificationDelay/UpdateBARWithinSessionModificationRequest", + structured: ie.NewUpdateBARWithinSessionModificationRequest( + ie.NewBARID(0xff), + ie.NewDownlinkDataNotificationDelay(100*time.Millisecond), + ), + decoded: 100 * time.Millisecond, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.DownlinkDataNotificationDelay() }, }, { description: "DurationMeasurement", structured: ie.NewDurationMeasurement(10 * time.Second), decoded: 10 * time.Second, decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.DurationMeasurement() }, + }, { + description: "DurationMeasurement/UsageReportWithinSessionModificationResponse", + structured: ie.NewUsageReportWithinSessionModificationResponse( + ie.NewURRID(0xffffffff), + ie.NewDurationMeasurement(10*time.Second), + ), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.DurationMeasurement() }, + }, { + description: "DurationMeasurement/UsageReportWithinSessionDeletionResponse", + structured: ie.NewUsageReportWithinSessionDeletionResponse( + ie.NewURRID(0xffffffff), + ie.NewDurationMeasurement(10*time.Second), + ), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.DurationMeasurement() }, + }, { + description: "DurationMeasurement/UsageReportWithinSessionReportRequest", + structured: ie.NewUsageReportWithinSessionReportRequest( + ie.NewURRID(0xffffffff), + ie.NewDurationMeasurement(10*time.Second), + ), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.DurationMeasurement() }, }, { description: "EthernetInactivityTimer", structured: ie.NewEthernetInactivityTimer(10 * time.Second), decoded: 10 * time.Second, decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.EthernetInactivityTimer() }, + }, { + description: "EthernetInactivityTimer/CreateURR", + structured: ie.NewCreateURR( + ie.NewURRID(0xffffffff), + ie.NewEthernetInactivityTimer(10*time.Second), + ), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.EthernetInactivityTimer() }, + }, { + description: "EthernetInactivityTimer/UpdateURR", + structured: ie.NewUpdateURR( + ie.NewURRID(0xffffffff), + ie.NewEthernetInactivityTimer(10*time.Second), + ), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.EthernetInactivityTimer() }, }, { description: "GracefulReleasePeriod/20hr", structured: ie.NewGracefulReleasePeriod(20 * time.Hour), @@ -74,26 +170,151 @@ func TestDurationIEs(t *testing.T) { structured: ie.NewMaximumPacketDelay(10 * time.Second), decoded: 10 * time.Second, decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.MaximumPacketDelay() }, + }, { + description: "MaximumPacketDelay/GTPUPathQoSControlInformation", + structured: ie.NewGTPUPathQoSControlInformation( + ie.NewRemoteGTPUPeer(0x0e, "127.0.0.1", "", ie.DstInterfaceAccess, "some.instance.example"), + ie.NewMaximumPacketDelay(10*time.Second), + ), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.MaximumPacketDelay() }, + }, { + description: "MaximumPacketDelay/GTPUPathQoSReport", + structured: ie.NewGTPUPathQoSReport( + ie.NewRemoteGTPUPeer(0x0e, "127.0.0.1", "", ie.DstInterfaceAccess, "some.instance.example"), + ie.NewMaximumPacketDelay(10*time.Second), + ), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.MaximumPacketDelay() }, + }, { + description: "MaximumPacketDelay/QoSInformationInGTPUPathQoSReport", + structured: ie.NewQoSInformationInGTPUPathQoSReport( + ie.NewTransportLevelMarking(0x1111), + ie.NewMaximumPacketDelay(10*time.Second), + ), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.MaximumPacketDelay() }, + }, { + description: "MeasurementPeriod", + structured: ie.NewMeasurementPeriod(10 * time.Second), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.MeasurementPeriod() }, + }, { + description: "MeasurementPeriod/CreateURR", + structured: ie.NewCreateURR( + ie.NewURRID(0xffffffff), + ie.NewMeasurementPeriod(10*time.Second), + ), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.MeasurementPeriod() }, + }, { + description: "MeasurementPeriod/UpdateURR", + structured: ie.NewUpdateURR( + ie.NewURRID(0xffffffff), + ie.NewMeasurementPeriod(10*time.Second), + ), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.MeasurementPeriod() }, + }, { + description: "MeasurementPeriod/QoSMonitoringPerQoSFlowControlInformation", + structured: ie.NewQoSMonitoringPerQoSFlowControlInformation( + ie.NewQFI(0x01), + ie.NewMeasurementPeriod(10*time.Second), + ), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.MeasurementPeriod() }, }, { description: "MinimumPacketDelay", structured: ie.NewMinimumPacketDelay(10 * time.Second), decoded: 10 * time.Second, decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.MinimumPacketDelay() }, + }, { + description: "MinimumPacketDelay/GTPUPathQoSControlInformation", + structured: ie.NewGTPUPathQoSControlInformation( + ie.NewRemoteGTPUPeer(0x0e, "127.0.0.1", "", ie.DstInterfaceAccess, "some.instance.example"), + ie.NewMinimumPacketDelay(10*time.Second), + ), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.MinimumPacketDelay() }, + }, { + description: "MinimumPacketDelay/GTPUPathQoSReport", + structured: ie.NewGTPUPathQoSReport( + ie.NewRemoteGTPUPeer(0x0e, "127.0.0.1", "", ie.DstInterfaceAccess, "some.instance.example"), + ie.NewMinimumPacketDelay(10*time.Second), + ), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.MinimumPacketDelay() }, + }, { + description: "MinimumPacketDelay/QoSInformationInGTPUPathQoSReport", + structured: ie.NewQoSInformationInGTPUPathQoSReport( + ie.NewTransportLevelMarking(0x1111), + ie.NewMinimumPacketDelay(10*time.Second), + ), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.MinimumPacketDelay() }, }, { description: "MinimumWaitTime", structured: ie.NewMinimumWaitTime(10 * time.Second), decoded: 10 * time.Second, decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.MinimumWaitTime() }, + }, { + description: "MinimumWaitTime/QoSMonitoringPerQoSFlowControlInformation", + structured: ie.NewQoSMonitoringPerQoSFlowControlInformation( + ie.NewQFI(0x01), + ie.NewMinimumWaitTime(10*time.Second), + ), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.MinimumWaitTime() }, }, { description: "QuotaHoldingTime", structured: ie.NewQuotaHoldingTime(10 * time.Second), decoded: 10 * time.Second, decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.QuotaHoldingTime() }, + }, { + description: "QuotaHoldingTime/CreateURR", + structured: ie.NewCreateURR( + ie.NewURRID(0xffffffff), + ie.NewQuotaHoldingTime(10*time.Second), + ), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.QuotaHoldingTime() }, + }, { + description: "QuotaHoldingTime/UpdateURR", + structured: ie.NewUpdateURR( + ie.NewURRID(0xffffffff), + ie.NewQuotaHoldingTime(10*time.Second), + ), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.QuotaHoldingTime() }, }, { description: "SubsequentTimeQuota", structured: ie.NewSubsequentTimeQuota(10 * time.Second), decoded: 10 * time.Second, decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.SubsequentTimeQuota() }, + }, { + description: "SubsequentTimeQuota/CreateURR", + structured: ie.NewCreateURR( + ie.NewURRID(0xffffffff), + ie.NewSubsequentTimeQuota(10*time.Second), + ), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.SubsequentTimeQuota() }, + }, { + description: "SubsequentTimeQuota/UpdateURR", + structured: ie.NewUpdateURR( + ie.NewURRID(0xffffffff), + ie.NewSubsequentTimeQuota(10*time.Second), + ), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.SubsequentTimeQuota() }, + }, { + description: "SubsequentTimeQuota/AdditionalMonitoringTime", + structured: ie.NewAdditionalMonitoringTime( + ie.NewMonitoringTime(time.Date(2019, time.January, 1, 0, 0, 0, 0, time.UTC)), + ie.NewSubsequentTimeQuota(10*time.Second), + ), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.SubsequentTimeQuota() }, }, { description: "TimeOffsetMeasurement", structured: ie.NewTimeOffsetMeasurement(10 * time.Second), @@ -104,11 +325,43 @@ func TestDurationIEs(t *testing.T) { structured: ie.NewTimeOffsetThreshold(10 * time.Second), decoded: 10 * time.Second, decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.TimeOffsetThreshold() }, + }, { + description: "TimeOffsetThreshold/ClockDriftControlInformation", + structured: ie.NewClockDriftControlInformation( + ie.NewRequestedClockDriftInformation(1, 1), + ie.NewTimeOffsetThreshold(10*time.Second), + ), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.TimeOffsetThreshold() }, + }, { + description: "TimeOffsetThreshold/ClockDriftReport", + structured: ie.NewClockDriftReport( + ie.NewTSNTimeDomainNumber(255), + ie.NewTimeOffsetThreshold(10*time.Second), + ), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.TimeOffsetThreshold() }, }, { description: "TimeQuota", structured: ie.NewTimeQuota(10 * time.Second), decoded: 10 * time.Second, decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.TimeQuota() }, + }, { + description: "TimeQuota/CreateURR", + structured: ie.NewCreateURR( + ie.NewURRID(0xffffffff), + ie.NewTimeQuota(10*time.Second), + ), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.TimeQuota() }, + }, { + description: "TimeQuota/UpdateURR", + structured: ie.NewUpdateURR( + ie.NewURRID(0xffffffff), + ie.NewTimeQuota(10*time.Second), + ), + decoded: 10 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.TimeQuota() }, }, { description: "Timer/20hr", structured: ie.NewTimer(20 * time.Hour), @@ -124,6 +377,22 @@ func TestDurationIEs(t *testing.T) { structured: ie.NewTimer(30 * time.Second), decoded: 30 * time.Second, decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.Timer() }, + }, { + description: "Timer/OverloadControlInformation", + structured: ie.NewOverloadControlInformation( + ie.NewSequenceNumber(0xffffffff), + ie.NewTimer(30*time.Second), + ), + decoded: 30 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.Timer() }, + }, { + description: "Timer/GTPUPathQoSControlInformation", + structured: ie.NewGTPUPathQoSControlInformation( + ie.NewRemoteGTPUPeer(0x0e, "127.0.0.1", "", ie.DstInterfaceAccess, "some.instance.example"), + ie.NewTimer(30*time.Second), + ), + decoded: 30 * time.Second, + decoderFunc: func(i *ie.IE) (time.Duration, error) { return i.Timer() }, }, { description: "UserPlaneInactivityTimer", structured: ie.NewUserPlaneInactivityTimer(10 * time.Second),