X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=e2ap%2Fpkg%2Fconv%2Fplmn_test.go;h=3740f533fc0bb6a96d17a6ec90f431cb293eab7a;hb=14f827331f7ae565d33cdf23c82f7794d3fc2d0d;hp=20a66177486e68fbbe67ff21b970f608e3af3695;hpb=47942b4fd845472cd4f669bdcc5320be71f1570c;p=ric-plt%2Fsubmgr.git

diff --git a/e2ap/pkg/conv/plmn_test.go b/e2ap/pkg/conv/plmn_test.go
index 20a6617..3740f53 100644
--- a/e2ap/pkg/conv/plmn_test.go
+++ b/e2ap/pkg/conv/plmn_test.go
@@ -20,69 +20,237 @@
 package conv
 
 import (
+	"bytes"
 	"testing"
 )
 
-func TestPlmnId1(t *testing.T) {
-
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+func TestPlmnId(t *testing.T) {
 	var ident PlmnIdentity
-	ident.StringPut("23350")
+	ident.Set("12345")
+	if ident.Mcc != "123" {
+		t.Errorf("TestPlmnId: mcc expect 123 was %s", ident.Mcc)
+	}
+	if ident.Mnc != "45" {
+		t.Errorf("TestPlmnId: mnc expect 45 was %s", ident.Mnc)
+	}
+
+	ident.Set("123456")
+	if ident.Mcc != "123" {
+		t.Errorf("TestPlmnId: mcc expect 123 was %s", ident.Mcc)
+	}
+	if ident.Mnc != "456" {
+		t.Errorf("TestPlmnId: mnc expect 456 was %s", ident.Mnc)
+	}
+
+}
+
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+func TestPlmnIdBcd1(t *testing.T) {
 
-	if ident.Val[0] != 0x32 {
-		t.Errorf("TestPlmnId1: ident.val[0] expected 0x32 got 0x%x", ident.Val[0])
+	var encident PlmnIdentityBcd
+	encident.Mcc = "233"
+	encident.Mnc = "50"
+	encbuf := new(bytes.Buffer)
+	retlen, err := encident.EncodeTo(encbuf)
+
+	if err != nil {
+		t.Errorf("TestPlmnIdBcd1: EncodeTo err %s", err.Error())
+	}
+	if retlen != 3 {
+		t.Errorf("TestPlmnIdBcd1: EncodeTo expected len 3 got %d", retlen)
 	}
 
-	if ident.Val[1] != 0xf3 {
-		t.Errorf("TestPlmnId1: ident.val[1] expected 0xf3 got 0x%x", ident.Val[1])
+	encdata := encbuf.Bytes()
+
+	if encdata[0] != 0x23 {
+		t.Errorf("TestPlmnIdBcd1: encident.val[0] expected 0x23 got 0x%x", encdata[0])
 	}
 
-	if ident.Val[2] != 0x05 {
-		t.Errorf("TestPlmnId1: ident.val[2] expected 0x05 got 0x%x", ident.Val[2])
+	if encdata[1] != 0x3f {
+		t.Errorf("TestPlmnIdBcd1: encident.val[1] expected 0x3f got 0x%x", encdata[1])
 	}
 
-	fullstr := ident.String()
-	if fullstr != "23350" {
-		t.Errorf("TestPlmnId2: fullstr expected 23350 got %s", fullstr)
+	if encdata[2] != 0x50 {
+		t.Errorf("TestPlmnIdBcd1: encident.val[2] expected 0x50 got 0x%x", encdata[2])
 	}
 
-	mccstr := ident.MccString()
-	if mccstr != "233" {
-		t.Errorf("TestPlmnId1: mcc expected 233 got %s", mccstr)
+	var decident PlmnIdentityBcd
+	decbuf := []byte{0x23, 0x3f, 0x50}
+
+	reader := bytes.NewReader(decbuf)
+	retlen, err = decident.DecodeFrom(reader)
+
+	if err != nil {
+		t.Errorf("TestPlmnIdBcd1: DecodeFrom err %s", err.Error())
 	}
-	mncstr := ident.MncString()
-	if mncstr != "50" {
-		t.Errorf("TestPlmnId1: mnc expected 50 got %s", mncstr)
+	if retlen != 3 {
+		t.Errorf("TestPlmnIdBcd1: DecodeFrom expected len 3 got %d", retlen)
+	}
+
+	if decident.Mcc != "233" {
+		t.Errorf("TestPlmnIdBcd1: mcc expected 233 got %s", decident.Mcc)
+	}
+	if decident.Mnc != "50" {
+		t.Errorf("TestPlmnIdBcd1: mnc expected 50 got %s", decident.Mnc)
 	}
 }
 
-func TestPlmnId2(t *testing.T) {
+func TestPlmnIdBcd2(t *testing.T) {
 
-	var ident PlmnIdentity
-	ident.StringPut("233550")
+	var encident PlmnIdentityBcd
 
-	if ident.Val[0] != 0x32 {
-		t.Errorf("TestPlmnId1: ident.val[0] expected 0x32 got 0x%x", ident.Val[0])
+	encident.Mcc = "233"
+	encident.Mnc = "550"
+	encbuf := new(bytes.Buffer)
+	retlen, err := encident.EncodeTo(encbuf)
+
+	if err != nil {
+		t.Errorf("TestPlmnIdBcd2: EncodeTo err %s", err.Error())
+	}
+	if retlen != 3 {
+		t.Errorf("TestPlmnIdBcd2: EncodeTo expected len 3 got %d", retlen)
+	}
+
+	encdata := encbuf.Bytes()
+
+	if encdata[0] != 0x23 {
+		t.Errorf("TestPlmnIdBcd2: encident.val[0] expected 0x23 got 0x%x", encdata[0])
 	}
 
-	if ident.Val[1] != 0x03 {
-		t.Errorf("TestPlmnId1: ident.val[1] expected 0x03 got 0x%x", ident.Val[1])
+	if encdata[1] != 0x35 {
+		t.Errorf("TestPlmnIdBcd1: encident.val[1] expected 0x35 got 0x%x", encdata[1])
 	}
 
-	if ident.Val[2] != 0x55 {
-		t.Errorf("TestPlmnId1: ident.val[2] expected 0x55 got 0x%x", ident.Val[2])
+	if encdata[2] != 0x50 {
+		t.Errorf("TestPlmnIdBcd2: encident.val[2] expected 0x50 got 0x%x", encdata[2])
 	}
 
-	fullstr := ident.String()
-	if fullstr != "233550" {
-		t.Errorf("TestPlmnId2: fullstr expected 233550 got %s", fullstr)
+	var decident PlmnIdentityBcd
+	decbuf := []byte{0x23, 0x35, 0x50}
+
+	reader := bytes.NewReader(decbuf)
+	retlen, err = decident.DecodeFrom(reader)
+
+	if err != nil {
+		t.Errorf("TestPlmnIdBcd2: DecodeFrom err %s", err.Error())
+	}
+	if retlen != 3 {
+		t.Errorf("TestPlmnIdBcd2: DecodeFrom expected len 3 got %d", retlen)
+	}
+
+	if decident.Mcc != "233" {
+		t.Errorf("TestPlmnIdBcd2: mcc expected 233 got %s", decident.Mcc)
+	}
+	if decident.Mnc != "550" {
+		t.Errorf("TestPlmnIdBcd2: mnc expected 550 got %s", decident.Mnc)
+	}
+}
+
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+func TestPlmnIdTbcd1(t *testing.T) {
+
+	var encident PlmnIdentityTbcd
+	encident.Mcc = "233"
+	encident.Mnc = "50"
+	encbuf := new(bytes.Buffer)
+	retlen, err := encident.EncodeTo(encbuf)
+
+	if err != nil {
+		t.Errorf("TestPlmnIdTbcd1: EncodeTo err %s", err.Error())
+	}
+	if retlen != 3 {
+		t.Errorf("TestPlmnIdTbcd1: EncodeTo expected len 3 got %d", retlen)
+	}
+
+	encdata := encbuf.Bytes()
+
+	if encdata[0] != 0x32 {
+		t.Errorf("TestPlmnIdTbcd1: encident.val[0] expected 0x32 got 0x%x", encdata[0])
+	}
+
+	if encdata[1] != 0xf3 {
+		t.Errorf("TestPlmnIdTbcd1: encident.val[1] expected 0xf3 got 0x%x", encdata[1])
+	}
+
+	if encdata[2] != 0x05 {
+		t.Errorf("TestPlmnIdTbcd1: encident.val[2] expected 0x05 got 0x%x", encdata[2])
+	}
+
+	var decident PlmnIdentityTbcd
+	decbuf := []byte{0x32, 0xf3, 0x05}
+
+	reader := bytes.NewReader(decbuf)
+	retlen, err = decident.DecodeFrom(reader)
+
+	if err != nil {
+		t.Errorf("TestPlmnIdTbcd1: DecodeFrom err %s", err.Error())
+	}
+	if retlen != 3 {
+		t.Errorf("TestPlmnIdTbcd1: DecodeFrom expected len 3 got %d", retlen)
+	}
+
+	if decident.Mcc != "233" {
+		t.Errorf("TestPlmnIdTbcd1: mcc expected 233 got %s", decident.Mcc)
+	}
+	if decident.Mnc != "50" {
+		t.Errorf("TestPlmnIdTbcd1: mnc expected 50 got %s", decident.Mnc)
+	}
+}
+
+func TestPlmnIdTbcd2(t *testing.T) {
+
+	var encident PlmnIdentityTbcd
+
+	encident.Mcc = "233"
+	encident.Mnc = "550"
+	encbuf := new(bytes.Buffer)
+	retlen, err := encident.EncodeTo(encbuf)
+
+	if err != nil {
+		t.Errorf("TestPlmnIdTbcd2: EncodeTo err %s", err.Error())
+	}
+	if retlen != 3 {
+		t.Errorf("TestPlmnIdTbcd2: EncodeTo expected len 3 got %d", retlen)
+	}
+
+	encdata := encbuf.Bytes()
+
+	if encdata[0] != 0x32 {
+		t.Errorf("TestPlmnIdTbcd2: encident.val[0] expected 0x32 got 0x%x", encdata[0])
+	}
+
+	if encdata[1] != 0x03 {
+		t.Errorf("TestPlmnIdTbcd1: encident.val[1] expected 0x03 got 0x%x", encdata[1])
+	}
+
+	if encdata[2] != 0x55 {
+		t.Errorf("TestPlmnIdTbcd2: encident.val[2] expected 0x55 got 0x%x", encdata[2])
+	}
+
+	var decident PlmnIdentityTbcd
+	decbuf := []byte{0x32, 0x03, 0x55}
+
+	reader := bytes.NewReader(decbuf)
+	retlen, err = decident.DecodeFrom(reader)
+
+	if err != nil {
+		t.Errorf("TestPlmnIdTbcd2: DecodeFrom err %s", err.Error())
+	}
+	if retlen != 3 {
+		t.Errorf("TestPlmnIdTbcd2: DecodeFrom expected len 3 got %d", retlen)
 	}
 
-	mccstr := ident.MccString()
-	if mccstr != "233" {
-		t.Errorf("TestPlmnId2: mcc expected 233 got %s", mccstr)
+	if decident.Mcc != "233" {
+		t.Errorf("TestPlmnIdTbcd2: mcc expected 233 got %s", decident.Mcc)
 	}
-	mncstr := ident.MncString()
-	if mncstr != "550" {
-		t.Errorf("TestPlmnId2: mnc expected 550 got %s", mncstr)
+	if decident.Mnc != "550" {
+		t.Errorf("TestPlmnIdTbcd2: mnc expected 550 got %s", decident.Mnc)
 	}
 }