diff --git a/internal/pkg/application/application_test.go b/internal/pkg/application/application_test.go
index ca2e2b9..7670e3b 100644
--- a/internal/pkg/application/application_test.go
+++ b/internal/pkg/application/application_test.go
@@ -34,6 +34,8 @@
 	"go.uber.org/atomic"
 )
 
+var test_data = "1234"
+
 func TestVoltApplication_RestoreNbDeviceFromDb(t *testing.T) {
 	type args struct {
 		cntx     context.Context
@@ -424,7 +426,7 @@
 	}
 	macAdd, _ := net.ParseMAC("ff:ff:ff:ff:ff:ff")
 	macPort := map[string]string{}
-	macPort[macAdd.String()] = "1234"
+	macPort[macAdd.String()] = test_data
 	tests := []struct {
 		name string
 		args args
@@ -433,7 +435,7 @@
 			name: "Positive_Case_UpdateMacInPortMap",
 			args: args{
 				macAddr: macAdd,
-				port:    "1234",
+				port:    test_data,
 			},
 		},
 	}
@@ -453,7 +455,7 @@
 	}
 	macAdd, _ := net.ParseMAC("ff:ff:ff:ff:ff:ff")
 	macPort := map[string]string{}
-	macPort[macAdd.String()] = "1234"
+	macPort[macAdd.String()] = test_data
 	tests := []struct {
 		name string
 		args args
@@ -464,7 +466,7 @@
 			args: args{
 				macAddr: macAdd,
 			},
-			want: "1234",
+			want: test_data,
 		},
 	}
 	for _, tt := range tests {
@@ -2375,3 +2377,323 @@
 		})
 	}
 }
+
+func TestVoltApplication_GetDeviceFromPort(t *testing.T) {
+	type args struct {
+		port string
+	}
+	voltDev := &VoltDevice{
+		Name:           "SDX6320031",
+		SerialNum:      "SDX6320031",
+		NniDhcpTrapVid: 123,
+		NniPort:        "16777216",
+		SouthBoundID:   "49686e2d-618f-4e8e-bca0-442ab850a63a",
+		Ports:          sync.Map{},
+	}
+	voltPort := &VoltPort{
+		Name:                     "16777216",
+		Device:                   "SDX6320031",
+		ID:                       16777216,
+		State:                    PortStateDown,
+		ChannelPerSubAlarmRaised: false,
+		Type:                     VoltPortTypeNni,
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    *VoltDevice
+		wantErr bool
+	}{
+		{
+			name: "Positive_Case_GetDeviceFromPort",
+			args: args{
+				port: "16777216",
+			},
+			want:    voltDev,
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			va := &VoltApplication{
+				DevicesDisc: sync.Map{},
+				PortsDisc:   sync.Map{},
+			}
+			va.PortsDisc.Store("16777216", voltPort)
+			va.DevicesDisc.Store("SDX6320031", voltDev)
+			got, err := va.GetDeviceFromPort(tt.args.port)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("VoltApplication.GetDeviceFromPort() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("VoltApplication.GetDeviceFromPort() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestVoltApplication_GetPortID(t *testing.T) {
+	type args struct {
+		port string
+	}
+	voltPort := &VoltPort{
+		Name:                     "16777216",
+		Device:                   "SDX6320031",
+		ID:                       16777216,
+		State:                    PortStateDown,
+		ChannelPerSubAlarmRaised: false,
+		Type:                     VoltPortTypeNni,
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    uint32
+		wantErr bool
+	}{
+		{
+			name: "Positive_Case_GetPortID",
+			args: args{
+				port: "16777216",
+			},
+			want:    16777216,
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			va := &VoltApplication{
+				PortsDisc: sync.Map{},
+			}
+			va.PortsDisc.Store("16777216", voltPort)
+			got, err := va.GetPortID(tt.args.port)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("VoltApplication.GetPortID() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if got != tt.want {
+				t.Errorf("VoltApplication.GetPortID() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestVoltApplication_GetPortName(t *testing.T) {
+	type args struct {
+		port uint32
+	}
+	voltPort := &VoltPort{
+		Name:                     "16777216",
+		Device:                   "SDX6320031",
+		ID:                       16777216,
+		State:                    PortStateDown,
+		ChannelPerSubAlarmRaised: false,
+		Type:                     VoltPortTypeNni,
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    string
+		wantErr bool
+	}{
+		{
+			name: "Positive_Case_GetPortID",
+			args: args{
+				port: 16777216,
+			},
+			want:    "16777216",
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			va := &VoltApplication{
+				PortsDisc: sync.Map{},
+			}
+			va.PortsDisc.Store("16777216", voltPort)
+			got, err := va.GetPortName(tt.args.port)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("VoltApplication.GetPortName() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if got != tt.want {
+				t.Errorf("VoltApplication.GetPortName() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestVoltApplication_PortUpInd(t *testing.T) {
+	type args struct {
+		cntx   context.Context
+		device string
+		port   string
+	}
+	voltDev := &VoltDevice{
+		Name:           "SDX6320031",
+		SerialNum:      "SDX6320031",
+		NniDhcpTrapVid: 123,
+		NniPort:        "16777472",
+		SouthBoundID:   "49686e2d-618f-4e8e-bca0-442ab850a63a",
+		Ports:          sync.Map{},
+		VpvsBySvlan:    util.NewConcurrentMap(),
+	}
+	voltPort := &VoltPort{
+		Name:                     "16777472",
+		Device:                   "SDX6320031",
+		ID:                       16777472,
+		State:                    PortStateUp,
+		ChannelPerSubAlarmRaised: false,
+		Type:                     VoltPortTypeNni,
+	}
+	voltServ := &VoltService{
+		VoltServiceOper: VoltServiceOper{
+			Device: "SDX6320031",
+		},
+		VoltServiceCfg: VoltServiceCfg{
+			IsActivated: true,
+		},
+	}
+	voltPortVnets := make([]*VoltPortVnet, 0)
+	voltPortVnet := &VoltPortVnet{
+		Device:           "SDX6320031",
+		Port:             "16777472",
+		DeleteInProgress: false,
+		services:         sync.Map{},
+		SVlan:            4096,
+		CVlan:            2310,
+		UniVlan:          4096,
+		SVlanTpid:        65,
+		servicesCount:    atomic.NewUint64(1),
+	}
+	voltPortVnets = append(voltPortVnets, voltPortVnet)
+
+	tests := []struct {
+		name string
+		args args
+	}{
+		{
+			name: "Positive_Case_PortUpInd",
+			args: args{
+				cntx:   context.Background(),
+				port:   "16777472",
+				device: "SDX6320031",
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			va := &VoltApplication{
+				DevicesDisc: sync.Map{},
+				VnetsByPort: sync.Map{},
+			}
+			va.DevicesDisc.Store("SDX6320031", voltDev)
+			voltDev.Ports.Store("16777472", voltPort)
+			va.VnetsByPort.Store("16777472", voltPortVnets)
+			voltPortVnet.services.Store("SDX6320031-1_SDX6320031-1-4096-2310-4096-65", voltServ)
+			voltapp := GetApplication()
+			voltapp.DevicesDisc.Store("SDX6320031", voltDev)
+			dbintf := mocks.NewMockDBIntf(gomock.NewController(t))
+			db = dbintf
+			dbintf.EXPECT().PutVpv(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+			va.PortUpInd(tt.args.cntx, tt.args.device, tt.args.port)
+		})
+	}
+}
+
+func TestVoltApplication_PortDownInd(t *testing.T) {
+	type args struct {
+		cntx   context.Context
+		device string
+		port   string
+	}
+	voltDev := &VoltDevice{
+		Name:           "SDX6320031",
+		SerialNum:      "SDX6320031",
+		NniDhcpTrapVid: 123,
+		NniPort:        "16777472",
+		SouthBoundID:   "49686e2d-618f-4e8e-bca0-442ab850a63a",
+		Ports:          sync.Map{},
+		VpvsBySvlan:    util.NewConcurrentMap(),
+	}
+	voltPort := &VoltPort{
+		Name:                     "16777472",
+		Device:                   "SDX6320031",
+		ID:                       16777472,
+		State:                    PortStateDown,
+		ChannelPerSubAlarmRaised: false,
+		Type:                     VoltPortTypeNni,
+	}
+	voltPortVnets := make([]*VoltPortVnet, 0)
+	voltPortVnet := &VoltPortVnet{
+		Device:           "SDX6320031",
+		Port:             "16777472",
+		DeleteInProgress: false,
+		services:         sync.Map{},
+		SVlan:            4096,
+		CVlan:            2310,
+		UniVlan:          4096,
+		SVlanTpid:        65,
+		servicesCount:    atomic.NewUint64(1),
+	}
+	voltPortVnets = append(voltPortVnets, voltPortVnet)
+	tests := []struct {
+		name string
+		args args
+	}{
+		{
+			name: "Positive_Case_PortDownInd",
+			args: args{
+				cntx:   context.Background(),
+				port:   "16777472",
+				device: "SDX6320031",
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			va := &VoltApplication{}
+			va.DevicesDisc.Store("SDX6320031", voltDev)
+			voltDev.Ports.Store("16777472", voltPort)
+			va.VnetsByPort.Store("16777472", voltPortVnets)
+			voltApp := GetApplication()
+			voltApp.DevicesDisc.Store("SDX6320031", voltDev)
+			va.PortDownInd(tt.args.cntx, tt.args.device, tt.args.port)
+		})
+	}
+}
+
+func TestVoltApplication_UpdateDeviceSerialNumberList(t *testing.T) {
+	type args struct {
+		oldOltSlNo string
+		newOltSlNo string
+	}
+	voltDev := &VoltDevice{
+		Name:           "49686e2d-618f-4e8e-bca0",
+		SerialNum:      "SDX6320031",
+		NniDhcpTrapVid: 123,
+		NniPort:        "16777472",
+		SouthBoundID:   "49686e2d-618f-4e8e-bca0-442ab850a63a",
+		Ports:          sync.Map{},
+		VpvsBySvlan:    util.NewConcurrentMap(),
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		{
+			name: "Positive_Case_UpdateDeviceSerialNumberList",
+			args: args{
+				oldOltSlNo: "SDX6320030",
+				newOltSlNo: "SDX6320031",
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			va := &VoltApplication{}
+			va.DevicesDisc.Store("SDX6320031", voltDev)
+			va.UpdateDeviceSerialNumberList(tt.args.oldOltSlNo, tt.args.newOltSlNo)
+		})
+	}
+}
diff --git a/internal/pkg/application/pppoeia_test.go b/internal/pkg/application/pppoeia_test.go
new file mode 100644
index 0000000..45b76fa
--- /dev/null
+++ b/internal/pkg/application/pppoeia_test.go
@@ -0,0 +1,266 @@
+/*
+* Copyright 2022-present Open Networking Foundation
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+ */
+
+package application
+
+import (
+	"context"
+	"net"
+	"sync"
+	"testing"
+	cntlr "voltha-go-controller/internal/pkg/controller"
+	"voltha-go-controller/internal/pkg/of"
+	"voltha-go-controller/internal/test/mocks"
+
+	"github.com/golang/mock/gomock"
+	"github.com/google/gopacket"
+	"github.com/google/gopacket/layers"
+	"github.com/stretchr/testify/assert"
+)
+
+var eth = &layers.Ethernet{
+	SrcMAC:       layers.EthernetBroadcast,
+	DstMAC:       layers.EthernetBroadcast,
+	EthernetType: layers.EthernetTypeARP,
+	Length:       uint16(1),
+}
+var dot1Q = &layers.Dot1Q{
+	Priority:     uint8(1),
+	DropEligible: true,
+	Type:         layers.EthernetTypeARP,
+}
+var LayerTypeDot2Q = []gopacket.Layer{
+	dot1Q,
+}
+
+func TestPppoeIaPacketTask_Start(t *testing.T) {
+	type args struct {
+		ctx    context.Context
+		taskID uint8
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		{
+			name: "PppoeIaPacketTask_Start",
+			args: args{
+				ctx:    context.Background(),
+				taskID: EtherType8100,
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			pppoe := &layers.PPPoE{
+				Version: uint8(1),
+			}
+			pkt := mocks.NewMockPacket(gomock.NewController(t))
+			var dpt = &PppoeIaPacketTask{
+				pkt: pkt,
+			}
+			pkt.EXPECT().Layer(layers.LayerTypePPPoE).Return(pppoe).Times(2)
+			pkt.EXPECT().Layer(layers.LayerTypeEthernet).Return(eth).Times(1)
+			pkt.EXPECT().Layer(layers.LayerTypeDot1Q).Return(dot1Q).Times(1)
+			pkt.EXPECT().Layers().Return(LayerTypeDot2Q).Times(1)
+			err := dpt.Start(tt.args.ctx, tt.args.taskID)
+			assert.Nil(t, err)
+		})
+	}
+}
+
+func TestVoltApplication_ProcessPPPoEIaPacket(t *testing.T) {
+	type args struct {
+		cntx   context.Context
+		device string
+		port   string
+		pkt    gopacket.Packet
+	}
+	pkt := mocks.NewMockPacket(gomock.NewController(t))
+	tests := []struct {
+		name string
+		args args
+	}{
+		{
+			name: "ProcessPPPoEIaPacket_ProcessUsPppoeIaPacket",
+			args: args{
+				cntx:   context.Background(),
+				device: test_device,
+				port:   "test_port",
+				pkt:    pkt,
+			},
+		},
+		{
+			name: "pppoel_nil",
+			args: args{
+				cntx:   context.Background(),
+				device: test_device,
+				port:   "test_port",
+				pkt:    pkt,
+			},
+		},
+		{
+			name: "pppoel_invalidType",
+			args: args{
+				cntx:   context.Background(),
+				device: test_device,
+				port:   "test_port",
+				pkt:    pkt,
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			va := &VoltApplication{}
+			// dot1Q := &layers.Dot1Q{
+			// 	Priority:     uint8(1),
+			// 	DropEligible: true,
+			// 	Type:         layers.EthernetTypeARP,
+			// }
+			// LayerTypeDot2Q := []gopacket.Layer{
+			// 	dot1Q,
+			// }
+			ga := GetApplication()
+			switch tt.name {
+			case "ProcessPPPoEIaPacket_ProcessUsPppoeIaPacket":
+				ga.DevicesDisc.Store(test_device, voltDevice)
+				pkt.EXPECT().Layer(layers.LayerTypePPPoE).Return(&layers.PPPoE{
+					Version: uint8(1),
+				}).Times(1)
+				pkt.EXPECT().Layers().Return(LayerTypeDot2Q).Times(2)
+				va.ProcessPPPoEIaPacket(tt.args.cntx, tt.args.device, tt.args.port, tt.args.pkt)
+			case "pppoel_nil":
+				pkt.EXPECT().Layer(layers.LayerTypePPPoE).Return(nil).Times(1)
+				va.ProcessPPPoEIaPacket(tt.args.cntx, tt.args.device, tt.args.port, tt.args.pkt)
+			case "pppoel_invalidType":
+				pkt.EXPECT().Layer(layers.LayerTypePPPoE).Return(&layers.ARP{}).Times(1)
+				va.ProcessPPPoEIaPacket(tt.args.cntx, tt.args.device, tt.args.port, tt.args.pkt)
+			}
+		})
+	}
+}
+
+func TestVoltApplication_ProcessUsPppoeIaPacket(t *testing.T) {
+	type args struct {
+		cntx   context.Context
+		device string
+		port   string
+		pkt    gopacket.Packet
+	}
+	pkt := mocks.NewMockPacket(gomock.NewController(t))
+	tests := []struct {
+		name string
+		args args
+	}{
+		{
+			name: "VoltApplication_ProcessUsPppoeIaPacket",
+			args: args{
+				cntx:   context.Background(),
+				device: test_device,
+				port:   "test_port",
+				pkt:    pkt,
+			},
+		},
+	}
+	macAdd, _ := net.ParseMAC("ff:ff:ff:ff:ff:ff")
+	macPort := map[string]string{}
+	macPort[macAdd.String()] = test_data
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			va := &VoltApplication{
+				macPortMap:  macPort,
+				VnetsByPort: sync.Map{},
+				DevicesDisc: sync.Map{},
+			}
+			voltServ := &VoltService{
+				VoltServiceOper: VoltServiceOper{
+					Device: "SDX6320031",
+				},
+				VoltServiceCfg: VoltServiceCfg{
+					IsActivated: true,
+					Pbits:       []of.PbitType{PbitMatchAll},
+				},
+			}
+			switch tt.name {
+			case "VoltApplication_ProcessUsPppoeIaPacket":
+				va.DevicesDisc.Store(test_device, voltDevice)
+				pkt.EXPECT().Layers().Return(LayerTypeDot2Q).Times(3)
+				voltPortVnet1[0].SVlan = 0
+				voltDevice.NniPort = "1"
+				va.VnetsByPort.Store("test_port", voltPortVnet1)
+				voltPortVnet1[0].PppoeIa = true
+				voltPortVnet1[0].AllowTransparent = true
+				voltPortVnet1[0].Port = test_data
+				pendingDeleteFlow := map[string]bool{}
+				pendingDeleteFlow["test_cookie"] = true
+				voltPortVnet1[0].PendingDeleteFlow = pendingDeleteFlow
+				dbintf := mocks.NewMockDBIntf(gomock.NewController(t))
+				db = dbintf
+				eth.SrcMAC = layers.EthernetBroadcast
+				dbintf.EXPECT().PutVpv(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).Times(1)
+				voltPortVnet1[0].services.Store("SDX6320031-1_SDX6320031-1-4096-2310-4096-65", voltServ)
+				pkt.EXPECT().Layer(layers.LayerTypeEthernet).Return(eth).Times(2)
+				pkt.EXPECT().Layer(layers.LayerTypePPPoE).Return(&layers.PPPoE{
+					Version: uint8(1),
+					Code:    layers.PPPoECodePADI,
+				}).Times(1)
+				pkt.EXPECT().Layer(layers.LayerTypeDot1Q).Return(dot1Q).Times(1)
+				_ = cntlr.NewController(context.Background(), mocks.NewMockApp(gomock.NewController(t)))
+				va.ProcessUsPppoeIaPacket(tt.args.cntx, tt.args.device, tt.args.port, tt.args.pkt)
+			}
+		})
+	}
+}
+
+func TestVoltApplication_ProcessDsPppoeIaPacket(t *testing.T) {
+	type args struct {
+		cntx   context.Context
+		device string
+		port   string
+		pkt    gopacket.Packet
+	}
+	pkt := mocks.NewMockPacket(gomock.NewController(t))
+	tests := []struct {
+		name string
+		args args
+	}{
+		{
+			name: "VoltApplication_ProcessDsPppoeIaPacket",
+			args: args{
+				cntx:   context.Background(),
+				device: test_device,
+				port:   "test_port",
+				pkt:    pkt,
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			va := &VoltApplication{}
+			pkt.EXPECT().Layer(layers.LayerTypeEthernet).Return(eth).Times(1)
+			pkt.EXPECT().Layer(layers.LayerTypePPPoE).Return(&layers.PPPoE{
+				Version: uint8(1),
+				Code:    layers.PPPoECodePADI,
+			}).Times(1)
+			pkt.EXPECT().Layer(layers.LayerTypeDot1Q).Return(dot1Q).Times(1)
+			pkt.EXPECT().Layers().Return(LayerTypeDot2Q).Times(3)
+			dbintf := mocks.NewMockDBIntf(gomock.NewController(t))
+			db = dbintf
+			dbintf.EXPECT().PutVpv(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).Times(1)
+			va.ProcessDsPppoeIaPacket(tt.args.cntx, tt.args.device, tt.args.port, tt.args.pkt)
+		})
+	}
+}
diff --git a/internal/pkg/application/service_test.go b/internal/pkg/application/service_test.go
index b9c458b..c687e55 100644
--- a/internal/pkg/application/service_test.go
+++ b/internal/pkg/application/service_test.go
@@ -19,6 +19,8 @@
 	"context"
 	"encoding/json"
 	"errors"
+	"net"
+	"reflect"
 	"sync"
 	"testing"
 	"voltha-go-controller/internal/pkg/controller"
@@ -48,8 +50,9 @@
 }
 
 var voltMeter = &VoltMeter{
-	Name:    "test_volt_meter",
-	Version: "test_version",
+	Name:               "test_volt_meter",
+	Version:            "test_version",
+	AssociatedServices: 3,
 }
 
 var voltVnet = &VoltVnet{
@@ -74,6 +77,26 @@
 	State: cntlr.DeviceStateDOWN,
 }
 
+var voltDevice2 = &VoltDevice{
+	Name:              "test_name",
+	State:             controller.DeviceStateUP,
+	FlowAddEventMap:   util.NewConcurrentMap(),
+	FlowDelEventMap:   util.NewConcurrentMap(),
+	SerialNum:         "test_serial_number",
+	MigratingServices: util.NewConcurrentMap(),
+}
+
+var voltService2 = &VoltService{
+	Version: "test_version",
+	VoltServiceCfg: VoltServiceCfg{
+		VnetID:  "test_vnet_id",
+		Port:    "test_port",
+		SVlan:   of.VlanAny,
+		CVlan:   of.VlanAny,
+		UniVlan: of.VlanAny,
+	},
+}
+
 var GetDeviceFromPort_error = "GetDeviceFromPort_error"
 
 func TestVoltApplication_RestoreSvcsFromDb(t *testing.T) {
@@ -105,7 +128,7 @@
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			voltService := &VoltService{
+			voltService4 := &VoltService{
 				VoltServiceOper: VoltServiceOper{
 					Device:           "SDX6320031",
 					ForceDelete:      true,
@@ -116,7 +139,7 @@
 				},
 			}
 			serviceToDelete := map[string]bool{}
-			serviceToDelete[voltService.VoltServiceCfg.Name] = true
+			serviceToDelete[voltService4.VoltServiceCfg.Name] = true
 			va := &VoltApplication{
 				ServicesToDelete: serviceToDelete,
 			}
@@ -125,7 +148,7 @@
 			switch tt.name {
 			case "VoltApplication_RestoreSvcsFromDb":
 
-				b, err := json.Marshal(voltService)
+				b, err := json.Marshal(voltService4)
 				if err != nil {
 					panic(err)
 				}
@@ -441,6 +464,19 @@
 				serviceMigration: true,
 			},
 		},
+		{
+			name: "GetMeterByID_not_nil",
+			args: args{
+				cntx:        context.Background(),
+				name:        "test_name",
+				forceDelete: true,
+				newSvc: &VoltServiceCfg{
+					Name: "vs_cfg_name",
+					Port: "test_port",
+				},
+				serviceMigration: true,
+			},
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -448,7 +484,7 @@
 				ServiceByName: sync.Map{},
 				VnetsByPort:   sync.Map{},
 			}
-			voltService := &VoltService{
+			voltService3 := &VoltService{
 				Version: "test_version",
 				VoltServiceCfg: VoltServiceCfg{
 					Port:    "4096-4096-4096",
@@ -457,13 +493,30 @@
 					UniVlan: of.VlanAny,
 				},
 			}
-			va.ServiceByName.Store(tt.args.name, voltService)
-			va.VnetsByPort.Store("4096-4096-4096", voltPortVnet1)
-			dbintf := mocks.NewMockDBIntf(gomock.NewController(t))
-			db = dbintf
-			dbintf.EXPECT().DelService(gomock.Any(), gomock.Any()).AnyTimes()
-			dbintf.EXPECT().PutService(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
-			va.DelService(tt.args.cntx, tt.args.name, tt.args.forceDelete, tt.args.newSvc, tt.args.serviceMigration)
+			switch tt.name {
+			case "VoltApplication_DelService":
+				va.ServiceByName.Store(tt.args.name, voltService3)
+				va.VnetsByPort.Store("4096-4096-4096", voltPortVnet1)
+				dbintf := mocks.NewMockDBIntf(gomock.NewController(t))
+				db = dbintf
+				dbintf.EXPECT().DelService(gomock.Any(), gomock.Any()).AnyTimes()
+				dbintf.EXPECT().PutService(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+				va.DelService(tt.args.cntx, tt.args.name, tt.args.forceDelete, tt.args.newSvc, tt.args.serviceMigration)
+			case "GetMeterByID_not_nil":
+				va.ServiceByName.Store(tt.args.name, voltService3)
+				va.VnetsByPort.Store("4096-4096-4096", voltPortVnet1)
+				voltService3.AggDsMeterID = uint32(1)
+				voltService3.DsMeterID = uint32(1)
+				voltService3.UsMeterID = uint32(2)
+				va.MeterMgr.MetersByID.Store(voltService3.AggDsMeterID, voltMeter)
+				va.MeterMgr.MetersByID.Store(voltService3.DsMeterID, voltMeter)
+				va.MeterMgr.MetersByID.Store(voltService3.UsMeterID, voltMeter)
+				dbintf := mocks.NewMockDBIntf(gomock.NewController(t))
+				db = dbintf
+				dbintf.EXPECT().DelService(gomock.Any(), gomock.Any()).AnyTimes()
+				dbintf.EXPECT().PutService(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+				va.DelService(tt.args.cntx, tt.args.name, tt.args.forceDelete, tt.args.newSvc, tt.args.serviceMigration)
+			}
 		})
 	}
 }
@@ -910,7 +963,7 @@
 			name: "VoltApplication_ActivateService",
 			args: args{
 				cntx:     context.Background(),
-				deviceID: "test_name",
+				deviceID: DeviceAny,
 				portNo:   "test_port",
 				sVlan:    of.VlanNone,
 				cVlan:    of.VlanAny,
@@ -939,6 +992,28 @@
 				tpID:     AnyVlan,
 			},
 		},
+		{
+			name: "deviceID != device.Name",
+			args: args{
+				cntx:     context.Background(),
+				deviceID: "test_name1",
+				portNo:   "test_port",
+				sVlan:    of.VlanNone,
+				cVlan:    of.VlanAny,
+				tpID:     AnyVlan,
+			},
+		},
+		{
+			name: "sVlan != of.VlanNone && sVlan != vs.SVlan",
+			args: args{
+				cntx:     context.Background(),
+				deviceID: "test_name",
+				portNo:   "test_port",
+				sVlan:    1,
+				cVlan:    of.VlanAny,
+				tpID:     AnyVlan,
+			},
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -992,6 +1067,31 @@
 			case GetDeviceFromPort_error:
 				err := va.ActivateService(tt.args.cntx, tt.args.deviceID, tt.args.portNo, tt.args.sVlan, tt.args.cVlan, tt.args.tpID)
 				assert.NotNil(t, err)
+			case "deviceID != device.Name":
+				var voltPortTest1 = &VoltPort{
+					Name:   "test_name",
+					State:  PortStateUp,
+					Device: test_device,
+				}
+				var voltDevice_test = &VoltDevice{
+					Name:            "",
+					State:           controller.DeviceStateUP,
+					FlowAddEventMap: util.NewConcurrentMap(),
+					FlowDelEventMap: util.NewConcurrentMap(),
+					SerialNum:       "test_serial_number",
+				}
+				va.PortsDisc.Store("test_port", voltPortTest1)
+				va.DevicesDisc.Store(test_device, voltDevice_test)
+				err := va.ActivateService(tt.args.cntx, tt.args.deviceID, tt.args.portNo, tt.args.sVlan, tt.args.cVlan, tt.args.tpID)
+				assert.NotNil(t, err)
+			case "sVlan != of.VlanNone && sVlan != vs.SVlan":
+				voltPortTest.Device = test_device
+				va.PortsDisc.Store("test_port", voltPortTest)
+				va.DevicesDisc.Store(test_device, voltDevice)
+				va.ServiceByName.Store("test_name", voltServiceTest)
+				if err := va.ActivateService(tt.args.cntx, tt.args.deviceID, tt.args.portNo, tt.args.sVlan, tt.args.cVlan, tt.args.tpID); (err != nil) != tt.wantErr {
+					t.Errorf("VoltApplication.ActivateService() error = %v, wantErr %v", err, tt.wantErr)
+				}
 			}
 		})
 	}
@@ -1522,6 +1622,16 @@
 			},
 			want: false,
 		},
+		{
+			name: "nvs.IsOption82Enabled != evs.IsOption82Enabled",
+			args: args{
+				evs: &VoltServiceCfg{
+					IsOption82Enabled: true,
+				},
+				nvs: &VoltServiceCfg{},
+			},
+			want: false,
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -1542,7 +1652,8 @@
 				"nvs.AllowTransparent != evs.AllowTransparent",
 				"nvs.EnableMulticastKPI != evs.EnableMulticastKPI", "nvs.DataRateAttr != evs.DataRateAttr",
 				"nvs.MinDataRateUs != evs.MinDataRateUs", "nvs.MinDataRateDs != evs.MinDataRateDs",
-				"nvs.MaxDataRateUs != evs.MaxDataRateUs", "nvs.MaxDataRateDs != evs.MaxDataRateDs":
+				"nvs.MaxDataRateUs != evs.MaxDataRateUs", "nvs.MaxDataRateDs != evs.MaxDataRateDs",
+				"nvs.IsOption82Enabled != evs.IsOption82Enabled":
 				if got := va.DeepEqualServicecfg(tt.args.evs, tt.args.nvs); got != tt.want {
 					t.Errorf("VoltApplication.DeepEqualServicecfg() = %v, want %v", got, tt.want)
 				}
@@ -1550,3 +1661,1414 @@
 		})
 	}
 }
+
+func Test_forceUpdateAllServices(t *testing.T) {
+	type args struct {
+		cntx context.Context
+		msr  *MigrateServicesRequest
+	}
+	servicesList := map[string]bool{}
+	servicesList[test_device] = true
+	tests := []struct {
+		name string
+		args args
+	}{
+		{
+			name: "forceUpdateAllServices",
+			args: args{
+				cntx: context.Background(),
+				msr: &MigrateServicesRequest{
+					ID:           "test_id",
+					ServicesList: servicesList,
+					DeviceID:     test_device,
+				},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ga := GetApplication()
+			dbintf := mocks.NewMockDBIntf(gomock.NewController(t))
+			db = dbintf
+			dbintf.EXPECT().DelMigrateServicesReq(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+			ga.ServiceByName.Store(test_device, voltService2)
+			voltService2.VoltServiceOper.Metadata = &MigrateServiceMetadata{
+				NewVnetID: "test_new_vnet_id",
+				RequestID: "test_request_id",
+			}
+			newConcurrentMap := util.NewConcurrentMap()
+			ga.DevicesDisc.Store(test_device, voltDevice2)
+			voltDevice2.MigratingServices.Set("test_vnet_id", newConcurrentMap)
+			migrateServicesRequest := &MigrateServicesRequest{
+				ID:           "test_id",
+				ServicesList: servicesList,
+			}
+			newConcurrentMap.Set("test_request_id", migrateServicesRequest)
+			dbintf.EXPECT().PutMigrateServicesReq(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+			forceUpdateAllServices(tt.args.cntx, tt.args.msr)
+		})
+	}
+}
+
+func TestVoltService_updateVnetProfile(t *testing.T) {
+	type args struct {
+		cntx     context.Context
+		deviceID string
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		{
+			name: "DeleteInProgress_true",
+			args: args{
+				cntx:     context.Background(),
+				deviceID: test_device,
+			},
+		},
+		{
+			name: "metadata_nil",
+			args: args{
+				cntx:     context.Background(),
+				deviceID: test_device,
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			switch tt.name {
+			case "DeleteInProgress_true":
+				vs := &VoltService{
+					VoltServiceOper: VoltServiceOper{
+						DeleteInProgress: true,
+					},
+				}
+				vs.updateVnetProfile(tt.args.cntx, tt.args.deviceID)
+			case "metadata_nil":
+				vs := &VoltService{
+					VoltServiceOper: VoltServiceOper{
+						Metadata: &MigrateServiceMetadata{},
+					},
+				}
+				vs.updateVnetProfile(tt.args.cntx, tt.args.deviceID)
+			}
+		})
+	}
+}
+
+func TestMigrateServicesRequest_serviceMigrated(t *testing.T) {
+	type args struct {
+		cntx        context.Context
+		serviceName string
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		{
+			name: "ServicesList_nil",
+			args: args{
+				cntx:        context.Background(),
+				serviceName: "test_service_name",
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			msr := &MigrateServicesRequest{
+				ServicesList: map[string]bool{},
+			}
+			dbintf := mocks.NewMockDBIntf(gomock.NewController(t))
+			db = dbintf
+			dbintf.EXPECT().DelMigrateServicesReq(gomock.All(), gomock.Any(), gomock.Any()).Return(nil).Times(1)
+			msr.serviceMigrated(tt.args.cntx, tt.args.serviceName)
+		})
+	}
+}
+
+func TestVoltApplication_TriggerPendingMigrateServicesReq(t *testing.T) {
+	type args struct {
+		cntx   context.Context
+		device string
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		{
+			name: "VoltApplication_TriggerPendingMigrateServicesReq",
+			args: args{
+				cntx:   context.Background(),
+				device: test_device,
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			va := &VoltApplication{
+				ServiceByName: sync.Map{},
+			}
+			migrateServicesRequest := &MigrateServicesRequest{
+				ID:        "test_id",
+				OldVnetID: "test_vnet_id",
+				DeviceID:  test_device,
+			}
+			b, err := json.Marshal(migrateServicesRequest)
+			if err != nil {
+				panic(err)
+			}
+			kvpair := map[string]*kvstore.KVPair{}
+			kvpair["test_device_id"] = &kvstore.KVPair{
+				Key:   "test_device_id",
+				Value: b,
+			}
+
+			dbintf := mocks.NewMockDBIntf(gomock.NewController(t))
+			db = dbintf
+			ga := GetApplication()
+			ga.DevicesDisc.Store(test_device, voltDevice2)
+			newConcurrentMap := util.NewConcurrentMap()
+			voltDevice2.MigratingServices.Set("test_vnet_id", newConcurrentMap)
+			dbintf.EXPECT().GetAllMigrateServicesReq(gomock.Any(), gomock.Any()).Return(kvpair, nil).AnyTimes()
+			va.TriggerPendingMigrateServicesReq(tt.args.cntx, tt.args.device)
+		})
+	}
+}
+
+func TestVoltApplication_FetchAndProcessAllMigrateServicesReq(t *testing.T) {
+	type args struct {
+		cntx      context.Context
+		device    string
+		msrAction func(context.Context, *MigrateServicesRequest)
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		{
+			name: "invalid_value_type",
+			args: args{
+				cntx:      context.Background(),
+				device:    test_device,
+				msrAction: func(ctx context.Context, msr *MigrateServicesRequest) {},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			va := &VoltApplication{
+				DevicesDisc: sync.Map{},
+			}
+			dbintf := mocks.NewMockDBIntf(gomock.NewController(t))
+			db = dbintf
+			kvpair := map[string]*kvstore.KVPair{}
+			kvpair["test_device_id"] = &kvstore.KVPair{
+				Key:   "test_device_id",
+				Value: "invalid_value",
+			}
+			dbintf.EXPECT().GetAllMigrateServicesReq(gomock.Any(), gomock.Any()).Return(kvpair, nil).AnyTimes()
+			va.FetchAndProcessAllMigrateServicesReq(tt.args.cntx, tt.args.device, tt.args.msrAction)
+		})
+	}
+}
+
+func TestVoltApplication_createMigrateServicesFromString(t *testing.T) {
+	type args struct {
+		b []byte
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		{
+			name: "Unmarshal_error",
+			args: args{
+				b: []byte{},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			va := &VoltApplication{
+				vendorID: test_device,
+			}
+			got := va.createMigrateServicesFromString(tt.args.b)
+			assert.NotNil(t, got)
+		})
+	}
+}
+
+func TestVoltApplication_getMigrateServicesRequest(t *testing.T) {
+	type args struct {
+		deviceID  string
+		oldVnetID string
+		requestID string
+	}
+	tests := []struct {
+		name string
+		args args
+		want *MigrateServicesRequest
+	}{
+		{
+			name: "GetDevice_nil",
+			args: args{
+				deviceID: test_device,
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			va := &VoltApplication{
+				vendorID: "vendorID",
+			}
+			if got := va.getMigrateServicesRequest(tt.args.deviceID, tt.args.oldVnetID, tt.args.requestID); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("VoltApplication.getMigrateServicesRequest() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestVoltDevice_AddMigratingServices(t *testing.T) {
+	type args struct {
+		msr *MigrateServicesRequest
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		{
+			name: "MigratingServices_Get_nil",
+			args: args{
+				msr: &MigrateServicesRequest{
+					ID: "test_id",
+				},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			d := &VoltDevice{
+				MigratingServices: util.NewConcurrentMap(),
+			}
+			d.AddMigratingServices(tt.args.msr)
+		})
+	}
+}
+
+func TestMigrateServicesRequest_ProcessMigrateServicesProfRequest(t *testing.T) {
+	type args struct {
+		cntx context.Context
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		{
+			name: "ServicesList_true",
+			args: args{
+				cntx: context.Background(),
+			},
+		},
+		{
+			name: "ServicesList_false",
+			args: args{
+				cntx: context.Background(),
+			},
+		},
+		{
+			name: "GetVnetByPort_nil",
+			args: args{
+				cntx: context.Background(),
+			},
+		},
+		{
+			name: "UsHSIAFlowsApplied_true",
+			args: args{
+				cntx: context.Background(),
+			},
+		},
+		{
+			name: "ServiceByName_nil",
+			args: args{
+				cntx: context.Background(),
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			dbintf := mocks.NewMockDBIntf(gomock.NewController(t))
+			db = dbintf
+			switch tt.name {
+			case "ServicesList_true":
+				servicesList := map[string]bool{}
+				servicesList[test_device] = true
+				msr := &MigrateServicesRequest{
+					ServicesList: servicesList,
+				}
+				dbintf.EXPECT().DelMigrateServicesReq(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+				msr.ProcessMigrateServicesProfRequest(tt.args.cntx)
+			case "ServicesList_false":
+				servicesList := map[string]bool{}
+				servicesList[test_device] = false
+				msr := &MigrateServicesRequest{
+					ServicesList: servicesList,
+				}
+				ga := GetApplication()
+				ga.ServiceByName.Store(test_device, voltService2)
+				ga.VnetsByPort.Store("test_port", voltPortVnet1)
+				msr.ProcessMigrateServicesProfRequest(tt.args.cntx)
+			case "GetVnetByPort_nil":
+				servicesList := map[string]bool{}
+				servicesList[test_device] = false
+				msr := &MigrateServicesRequest{
+					ServicesList: servicesList,
+				}
+				ga := GetApplication()
+				var voltService1 = &VoltService{
+					Version: "test_version",
+					VoltServiceCfg: VoltServiceCfg{
+						VnetID:  "test_vnet_id",
+						SVlan:   of.VlanAny,
+						CVlan:   of.VlanAny,
+						UniVlan: of.VlanAny,
+					},
+				}
+				ga.ServiceByName.Store(test_device, voltService1)
+				ga.VnetsByPort.Store("test_port1", nil)
+				msr.ProcessMigrateServicesProfRequest(tt.args.cntx)
+			case "UsHSIAFlowsApplied_true":
+				servicesList := map[string]bool{}
+				servicesList[test_device] = false
+				msr := &MigrateServicesRequest{
+					ServicesList: servicesList,
+				}
+				ga := GetApplication()
+				voltService2.UsHSIAFlowsApplied = true
+				ga.ServiceByName.Store(test_device, voltService2)
+				ga.VnetsByPort.Store("test_port", voltPortVnet1)
+				dbintf.EXPECT().PutVpv(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+				dbintf.EXPECT().PutService(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+				msr.ProcessMigrateServicesProfRequest(tt.args.cntx)
+			case "ServiceByName_nil":
+				servicesList := map[string]bool{}
+				servicesList[""] = false
+				msr := &MigrateServicesRequest{
+					ServicesList: servicesList,
+				}
+				msr.ProcessMigrateServicesProfRequest(tt.args.cntx)
+			}
+		})
+	}
+}
+
+func TestVoltApplication_MigrateServices(t *testing.T) {
+	type args struct {
+		cntx        context.Context
+		serialNum   string
+		reqID       string
+		oldVnetID   string
+		newVnetID   string
+		serviceList []string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		{
+			name: "VoltApplication_MigrateServices",
+			args: args{
+				cntx:        context.Background(),
+				serialNum:   "test_serial_number",
+				reqID:       "test_reqid",
+				oldVnetID:   "test_old_vnet_id",
+				newVnetID:   "test_new_vnet_id",
+				serviceList: []string{"test_service_list_1", "test_service_list_2"},
+			},
+		},
+		{
+			name: "Old Vnet Id not found",
+			args: args{
+				cntx:        context.Background(),
+				serialNum:   "test_serial_number",
+				reqID:       "test_reqid",
+				oldVnetID:   "",
+				newVnetID:   "test_new_vnet_id",
+				serviceList: []string{"test_service_list_1", "test_service_list_2"},
+			},
+		},
+		{
+			name: "New Vnet Id not found",
+			args: args{
+				cntx:        context.Background(),
+				serialNum:   "test_serial_number",
+				reqID:       "test_reqid",
+				oldVnetID:   "test_old_vnet_id",
+				newVnetID:   "",
+				serviceList: []string{"test_service_list_1", "test_service_list_2"},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			va := &VoltApplication{
+				VnetsByName: sync.Map{},
+			}
+			voltVnet2 := &VoltVnet{
+				Version: "v3",
+				VnetConfig: VnetConfig{
+					Name:      "2310-4096-4096",
+					VnetType:  "Encapsulation",
+					SVlan:     2310,
+					CVlan:     4096,
+					UniVlan:   4096,
+					SVlanTpid: 33024,
+				},
+				VnetOper: VnetOper{
+					PendingDeviceToDelete: "SDX63200313",
+				},
+			}
+			switch tt.name {
+			case "VoltApplication_MigrateServices":
+				va.VnetsByName.Store("test_old_vnet_id", voltVnet2)
+				va.VnetsByName.Store("test_new_vnet_id", voltVnet2)
+				va.DevicesDisc.Store(test_device, voltDevice2)
+				dbintf := mocks.NewMockDBIntf(gomock.NewController(t))
+				db = dbintf
+				dbintf.EXPECT().PutMigrateServicesReq(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+				if err := va.MigrateServices(tt.args.cntx, tt.args.serialNum, tt.args.reqID, tt.args.oldVnetID, tt.args.newVnetID, tt.args.serviceList); (err != nil) != tt.wantErr {
+					t.Errorf("VoltApplication.MigrateServices() error = %v, wantErr %v", err, tt.wantErr)
+				}
+			case "Old Vnet Id not found":
+				va.VnetsByName.Store("test_old_vnet_id", voltVnet2)
+				err := va.MigrateServices(tt.args.cntx, tt.args.serialNum, tt.args.reqID, tt.args.oldVnetID, tt.args.newVnetID, tt.args.serviceList)
+				assert.NotNil(t, err)
+			case "New Vnet Id not found":
+				va.VnetsByName.Store("test_old_vnet_id", voltVnet2)
+				va.VnetsByName.Store("test_new_vnet_id", voltVnet2)
+				err := va.MigrateServices(tt.args.cntx, tt.args.serialNum, tt.args.reqID, tt.args.oldVnetID, tt.args.newVnetID, tt.args.serviceList)
+				assert.NotNil(t, err)
+			}
+		})
+	}
+}
+
+func TestMigrateServicesRequest_WriteToDB(t *testing.T) {
+	type args struct {
+		cntx context.Context
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		{
+			name: "PutMigrateServicesReq_error",
+			args: args{
+				cntx: context.Background(),
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			msr := &MigrateServicesRequest{
+				ID: test_device,
+			}
+			dbintf := mocks.NewMockDBIntf(gomock.NewController(t))
+			db = dbintf
+			dbintf.EXPECT().PutMigrateServicesReq(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(errors.New("error")).Times(1)
+			msr.WriteToDB(tt.args.cntx)
+		})
+	}
+}
+
+func TestVoltService_MatchesVlans(t *testing.T) {
+	type args struct {
+		vlans []of.VlanType
+	}
+	tests := []struct {
+		name string
+		args args
+		want bool
+	}{
+		{
+			name: "vlans_nil",
+			args: args{
+				vlans: []of.VlanType{},
+			},
+			want: false,
+		},
+		{
+			name: "MatchesVlans",
+			args: args{
+				vlans: []of.VlanType{
+					of.VlanAny,
+				},
+			},
+			want: true,
+		},
+		{
+			name: "vlans[0] != vs.CVlan",
+			args: args{
+				vlans: []of.VlanType{
+					of.VlanNone,
+				},
+			},
+			want: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			vs := &VoltService{
+				VoltServiceCfg: VoltServiceCfg{CVlan: of.VlanAny},
+			}
+			switch tt.name {
+			case "vlans_nil", "MatchesVlans", "vlans[0] != vs.CVlan":
+				if got := vs.MatchesVlans(tt.args.vlans); got != tt.want {
+					t.Errorf("VoltService.MatchesVlans() = %v, want %v", got, tt.want)
+				}
+			}
+		})
+	}
+}
+
+func TestVoltService_MatchesPbits(t *testing.T) {
+	type args struct {
+		pbits []of.PbitType
+	}
+	tests := []struct {
+		name string
+		args args
+		want bool
+	}{
+		{
+			name: "VoltService_MatchesPbits",
+			args: args{
+				pbits: []of.PbitType{
+					of.PbitMatchAll,
+				},
+			},
+			want: true,
+		},
+		{
+			name: "PbitType_nil",
+			args: args{
+				pbits: []of.PbitType{},
+			},
+			want: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			vs := &VoltService{
+				VoltServiceCfg: VoltServiceCfg{
+					Pbits: []of.PbitType{
+						of.PbitMatchAll,
+					},
+				},
+			}
+			switch tt.name {
+			case "VoltService_MatchesPbits", "PbitType_nil":
+				if got := vs.MatchesPbits(tt.args.pbits); got != tt.want {
+					t.Errorf("VoltService.MatchesPbits() = %v, want %v", got, tt.want)
+				}
+			}
+		})
+	}
+}
+
+func TestVoltApplication_DelServiceWithPrefix(t *testing.T) {
+	type args struct {
+		cntx   context.Context
+		prefix string
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		{
+			name: "VoltApplication_DelServiceWithPrefix",
+			args: args{
+				cntx:   context.Background(),
+				prefix: test_device,
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			va := &VoltApplication{
+				VnetsBySvlan: util.NewConcurrentMap(),
+			}
+			va.ServiceByName.Store(test_device, voltService)
+			va.VnetsByName.Store("0-0-0", voltVnet)
+			dbintf := mocks.NewMockDBIntf(gomock.NewController(t))
+			db = dbintf
+			dbintf.EXPECT().PutVnet(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).Times(1)
+			cuncurrentMap := &util.ConcurrentMap{
+				Count: atomic.NewUint64(0),
+			}
+			va.VnetsBySvlan.Set(of.VlanAny, cuncurrentMap)
+			dbintf.EXPECT().DelVnet(gomock.Any(), gomock.Any()).Return(nil).Times(1)
+			va.DelServiceWithPrefix(tt.args.cntx, tt.args.prefix)
+		})
+	}
+}
+
+func TestVoltService_FlowInstallFailure(t *testing.T) {
+	type args struct {
+		cookie    string
+		errorCode uint32
+		errReason string
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		{
+			name: "VoltService_FlowInstallFailure",
+			args: args{
+				cookie:    "test_cookie",
+				errorCode: uint32(1),
+				errReason: "err_reason",
+			},
+		},
+		{
+			name: "PendingFlows[cookie]_false",
+			args: args{
+				cookie:    "test_cookie",
+				errorCode: uint32(1),
+				errReason: "err_reason",
+			},
+		},
+	}
+	pendingFlows := map[string]bool{}
+	pendingFlows["test_cookie"] = true
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			vs := &VoltService{
+				VoltServiceOper: VoltServiceOper{},
+			}
+			switch tt.name {
+			case "VoltService_FlowInstallFailure":
+				vs.PendingFlows = pendingFlows
+				vs.FlowInstallFailure(tt.args.cookie, tt.args.errorCode, tt.args.errReason)
+			case "PendingFlows[cookie]_false":
+				vs.FlowInstallFailure(tt.args.cookie, tt.args.errorCode, tt.args.errReason)
+			}
+		})
+	}
+}
+
+func TestVoltService_FlowRemoveSuccess(t *testing.T) {
+	type args struct {
+		cntx   context.Context
+		cookie string
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		{
+			name: "GetDevice != nil",
+			args: args{
+				cntx:   context.Background(),
+				cookie: "test_cookie",
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			vs := &VoltService{
+				VoltServiceOper: VoltServiceOper{
+					Device: test_device,
+				},
+			}
+			ga := GetApplication()
+			ga.DevicesDisc.Store(test_device, voltDevice2)
+			voltDevice2.State = controller.DeviceStateUP
+			dbintf := mocks.NewMockDBIntf(gomock.NewController(t))
+			db = dbintf
+			dbintf.EXPECT().PutService(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+			vs.FlowRemoveSuccess(tt.args.cntx, tt.args.cookie)
+		})
+	}
+}
+
+func TestVoltService_setDSMatchActionVlanT0(t *testing.T) {
+	type args struct {
+		flow *of.VoltSubFlow
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		{
+			name: "VlanControl: ONUCVlanOLTSVlan",
+			args: args{
+				flow: &of.VoltSubFlow{
+					ErrorReason: "test_error_reason",
+					Cookie:      uint64(1),
+					OldCookie:   uint64(2),
+					TableID:     uint32(3),
+					Priority:    uint32(4),
+					State:       uint8(5),
+				},
+			},
+		},
+		{
+			name: "VlanControl: OLTCVlanOLTSVlan",
+			args: args{
+				flow: &of.VoltSubFlow{
+					ErrorReason: "test_error_reason",
+					Cookie:      uint64(1),
+					OldCookie:   uint64(2),
+					TableID:     uint32(3),
+					Priority:    uint32(4),
+					State:       uint8(5),
+				},
+			},
+		},
+		{
+			name: "VlanControl: ONUCVlan",
+			args: args{
+				flow: &of.VoltSubFlow{
+					ErrorReason: "test_error_reason",
+					Cookie:      uint64(1),
+					OldCookie:   uint64(2),
+					TableID:     uint32(3),
+					Priority:    uint32(4),
+					State:       uint8(5),
+				},
+			},
+		},
+		{
+			name: "VlanControl: OLTSVlan",
+			args: args{
+				flow: &of.VoltSubFlow{
+					ErrorReason: "test_error_reason",
+					Cookie:      uint64(1),
+					OldCookie:   uint64(2),
+					TableID:     uint32(3),
+					Priority:    uint32(4),
+					State:       uint8(5),
+				},
+			},
+		},
+		{
+			name: "VlanControl: OLTSVlan && UniVlan != of.VlanAny",
+			args: args{
+				flow: &of.VoltSubFlow{
+					ErrorReason: "test_error_reason",
+					Cookie:      uint64(1),
+					OldCookie:   uint64(2),
+					TableID:     uint32(3),
+					Priority:    uint32(4),
+					State:       uint8(5),
+				},
+			},
+		},
+		{
+			name: "invalid VlanControl",
+			args: args{
+				flow: &of.VoltSubFlow{
+					ErrorReason: "test_error_reason",
+					Cookie:      uint64(1),
+					OldCookie:   uint64(2),
+					TableID:     uint32(3),
+					Priority:    uint32(4),
+					State:       uint8(5),
+				},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			vs := &VoltService{
+				VoltServiceCfg: VoltServiceCfg{
+					SVlan:       of.VlanAny,
+					UniVlan:     of.VlanAny,
+					VlanControl: ONUCVlanOLTSVlan,
+				},
+			}
+			switch tt.name {
+			case "VlanControl: ONUCVlanOLTSVlan":
+				vs.VlanControl = ONUCVlanOLTSVlan
+				if err := vs.setDSMatchActionVlanT0(tt.args.flow); (err != nil) != tt.wantErr {
+					t.Errorf("VoltService.setDSMatchActionVlanT0() error = %v, wantErr %v", err, tt.wantErr)
+				}
+			case "VlanControl: OLTCVlanOLTSVlan":
+				vs.VlanControl = OLTCVlanOLTSVlan
+				if err := vs.setDSMatchActionVlanT0(tt.args.flow); (err != nil) != tt.wantErr {
+					t.Errorf("VoltService.setDSMatchActionVlanT0() error = %v, wantErr %v", err, tt.wantErr)
+				}
+			case "VlanControl: ONUCVlan":
+				vs.VlanControl = ONUCVlan
+				if err := vs.setDSMatchActionVlanT0(tt.args.flow); (err != nil) != tt.wantErr {
+					t.Errorf("VoltService.setDSMatchActionVlanT0() error = %v, wantErr %v", err, tt.wantErr)
+				}
+			case "VlanControl: OLTSVlan":
+				vs.VlanControl = OLTSVlan
+				vs.UniVlan = vs.CVlan
+				if err := vs.setDSMatchActionVlanT0(tt.args.flow); (err != nil) != tt.wantErr {
+					t.Errorf("VoltService.setDSMatchActionVlanT0() error = %v, wantErr %v", err, tt.wantErr)
+				}
+			case "VlanControl: OLTSVlan && UniVlan != of.VlanAny":
+				vs.VlanControl = OLTSVlan
+				if err := vs.setDSMatchActionVlanT0(tt.args.flow); (err != nil) != tt.wantErr {
+					t.Errorf("VoltService.setDSMatchActionVlanT0() error = %v, wantErr %v", err, tt.wantErr)
+				}
+			case "invalid VlanControl":
+				vs.VlanControl = 5
+				err := vs.setDSMatchActionVlanT0(tt.args.flow)
+				assert.NotNil(t, err)
+			}
+		})
+	}
+}
+
+func TestVoltService_setUSMatchActionVlanT1(t *testing.T) {
+	type args struct {
+		flow *of.VoltSubFlow
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		{
+			name: "VlanControl: ONUCVlanOLTSVlan",
+			args: args{
+				flow: &of.VoltSubFlow{
+					ErrorReason: "test_error_reason",
+					Cookie:      uint64(1),
+					OldCookie:   uint64(2),
+					TableID:     uint32(3),
+					Priority:    uint32(4),
+					State:       uint8(5),
+				},
+			},
+		},
+		{
+			name: "VlanControl: OLTCVlanOLTSVlan",
+			args: args{
+				flow: &of.VoltSubFlow{
+					ErrorReason: "test_error_reason",
+					Cookie:      uint64(1),
+					OldCookie:   uint64(2),
+					TableID:     uint32(3),
+					Priority:    uint32(4),
+					State:       uint8(5),
+				},
+			},
+		},
+		{
+			name: "VlanControl: ONUCVlan",
+			args: args{
+				flow: &of.VoltSubFlow{
+					ErrorReason: "test_error_reason",
+					Cookie:      uint64(1),
+					OldCookie:   uint64(2),
+					TableID:     uint32(3),
+					Priority:    uint32(4),
+					State:       uint8(5),
+				},
+			},
+		},
+		{
+			name: "VlanControl: OLTSVlan",
+			args: args{
+				flow: &of.VoltSubFlow{
+					ErrorReason: "test_error_reason",
+					Cookie:      uint64(1),
+					OldCookie:   uint64(2),
+					TableID:     uint32(3),
+					Priority:    uint32(4),
+					State:       uint8(5),
+				},
+			},
+		},
+		{
+			name: "VlanControl: OLTSVlan vs.UniVlan != of.VlanAny && vs.UniVlan != of.VlanNone",
+			args: args{
+				flow: &of.VoltSubFlow{
+					ErrorReason: "test_error_reason",
+					Cookie:      uint64(1),
+					OldCookie:   uint64(2),
+					TableID:     uint32(3),
+					Priority:    uint32(4),
+					State:       uint8(5),
+				},
+			},
+		},
+		{
+			name: "VlanControl: OLTSVlan vs.UniVlan == of.VlanNone",
+			args: args{
+				flow: &of.VoltSubFlow{
+					ErrorReason: "test_error_reason",
+					Cookie:      uint64(1),
+					OldCookie:   uint64(2),
+					TableID:     uint32(3),
+					Priority:    uint32(4),
+					State:       uint8(5),
+				},
+			},
+		},
+		{
+			name: "VlanControl: default",
+			args: args{
+				flow: &of.VoltSubFlow{
+					ErrorReason: "test_error_reason",
+					Cookie:      uint64(1),
+					OldCookie:   uint64(2),
+					TableID:     uint32(3),
+					Priority:    uint32(4),
+					State:       uint8(5),
+				},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			vs := &VoltService{
+				VoltServiceCfg: VoltServiceCfg{
+					SVlan:       of.VlanAny,
+					UniVlan:     of.VlanAny,
+					VlanControl: ONUCVlanOLTSVlan,
+				},
+			}
+			switch tt.name {
+			case "VlanControl: ONUCVlanOLTSVlan":
+				vs.VlanControl = ONUCVlanOLTSVlan
+				if err := vs.setUSMatchActionVlanT1(tt.args.flow); (err != nil) != tt.wantErr {
+					t.Errorf("VoltService.setDSMatchActionVlanT0() error = %v, wantErr %v", err, tt.wantErr)
+				}
+			case "VlanControl: OLTCVlanOLTSVlan":
+				vs.VlanControl = OLTCVlanOLTSVlan
+				if err := vs.setUSMatchActionVlanT1(tt.args.flow); (err != nil) != tt.wantErr {
+					t.Errorf("VoltService.setDSMatchActionVlanT0() error = %v, wantErr %v", err, tt.wantErr)
+				}
+			case "VlanControl: ONUCVlan":
+				vs.VlanControl = ONUCVlan
+				if err := vs.setUSMatchActionVlanT1(tt.args.flow); (err != nil) != tt.wantErr {
+					t.Errorf("VoltService.setDSMatchActionVlanT0() error = %v, wantErr %v", err, tt.wantErr)
+				}
+			case "VlanControl: OLTSVlan":
+				vs.VlanControl = OLTSVlan
+				if err := vs.setUSMatchActionVlanT1(tt.args.flow); (err != nil) != tt.wantErr {
+					t.Errorf("VoltService.setDSMatchActionVlanT0() error = %v, wantErr %v", err, tt.wantErr)
+				}
+			case "VlanControl: OLTSVlan vs.UniVlan != of.VlanAny && vs.UniVlan != of.VlanNone":
+				vs.VlanControl = OLTSVlan
+				vs.UniVlan = vs.CVlan
+				if err := vs.setUSMatchActionVlanT1(tt.args.flow); (err != nil) != tt.wantErr {
+					t.Errorf("VoltService.setDSMatchActionVlanT0() error = %v, wantErr %v", err, tt.wantErr)
+				}
+			case "VlanControl: OLTSVlan vs.UniVlan == of.VlanNone":
+				vs.VlanControl = OLTSVlan
+				vs.UniVlan = of.VlanNone
+				if err := vs.setUSMatchActionVlanT1(tt.args.flow); (err != nil) != tt.wantErr {
+					t.Errorf("VoltService.setDSMatchActionVlanT0() error = %v, wantErr %v", err, tt.wantErr)
+				}
+			case "VlanControl: default":
+				vs.VlanControl = 6
+				err := vs.setUSMatchActionVlanT1(tt.args.flow)
+				assert.NotNil(t, err)
+			}
+		})
+	}
+}
+
+func TestVoltService_setUSMatchActionVlanT0(t *testing.T) {
+	type args struct {
+		flow *of.VoltSubFlow
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		{
+			name: "vs.VlanControl: ONUCVlanOLTSVlan",
+			args: args{
+				flow: &of.VoltSubFlow{
+					ErrorReason: "test_error_reason",
+					Cookie:      uint64(1),
+					OldCookie:   uint64(2),
+					TableID:     uint32(3),
+					Priority:    uint32(4),
+					State:       uint8(5),
+				},
+			},
+		},
+		{
+			name: "vs.VlanControl: ONUCVlanOLTSVlan vs.UniVlan == of.VlanNone",
+			args: args{
+				flow: &of.VoltSubFlow{
+					ErrorReason: "test_error_reason",
+					Cookie:      uint64(1),
+					OldCookie:   uint64(2),
+					TableID:     uint32(3),
+					Priority:    uint32(4),
+					State:       uint8(5),
+				},
+			},
+		},
+		{
+			name: "vs.VlanControl: OLTCVlanOLTSVlan",
+			args: args{
+				flow: &of.VoltSubFlow{
+					ErrorReason: "test_error_reason",
+					Cookie:      uint64(1),
+					OldCookie:   uint64(2),
+					TableID:     uint32(3),
+					Priority:    uint32(4),
+					State:       uint8(5),
+				},
+			},
+		},
+		{
+			name: "vs.VlanControl: ONUCVlan",
+			args: args{
+				flow: &of.VoltSubFlow{
+					ErrorReason: "test_error_reason",
+					Cookie:      uint64(1),
+					OldCookie:   uint64(2),
+					TableID:     uint32(3),
+					Priority:    uint32(4),
+					State:       uint8(5),
+				},
+			},
+		},
+		{
+			name: "vs.VlanControl: ONUCVlan vs.UniVlan == of.VlanNone",
+			args: args{
+				flow: &of.VoltSubFlow{
+					ErrorReason: "test_error_reason",
+					Cookie:      uint64(1),
+					OldCookie:   uint64(2),
+					TableID:     uint32(3),
+					Priority:    uint32(4),
+					State:       uint8(5),
+				},
+			},
+		},
+		{
+			name: "vs.VlanControl: OLTSVlan",
+			args: args{
+				flow: &of.VoltSubFlow{
+					ErrorReason: "test_error_reason",
+					Cookie:      uint64(1),
+					OldCookie:   uint64(2),
+					TableID:     uint32(3),
+					Priority:    uint32(4),
+					State:       uint8(5),
+				},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			vs := &VoltService{}
+			switch tt.name {
+			case "vs.VlanControl: ONUCVlanOLTSVlan":
+				vs.VlanControl = ONUCVlanOLTSVlan
+				if err := vs.setUSMatchActionVlanT0(tt.args.flow); (err != nil) != tt.wantErr {
+					t.Errorf("VoltService.setUSMatchActionVlanT0() error = %v, wantErr %v", err, tt.wantErr)
+				}
+			case "vs.VlanControl: ONUCVlanOLTSVlan vs.UniVlan == of.VlanNone":
+				vs.VlanControl = ONUCVlanOLTSVlan
+				vs.UniVlan = of.VlanNone
+				if err := vs.setUSMatchActionVlanT0(tt.args.flow); (err != nil) != tt.wantErr {
+					t.Errorf("VoltService.setUSMatchActionVlanT0() error = %v, wantErr %v", err, tt.wantErr)
+				}
+			case "vs.VlanControl: OLTCVlanOLTSVlan":
+				vs.VlanControl = OLTCVlanOLTSVlan
+				if err := vs.setUSMatchActionVlanT0(tt.args.flow); (err != nil) != tt.wantErr {
+					t.Errorf("VoltService.setUSMatchActionVlanT0() error = %v, wantErr %v", err, tt.wantErr)
+				}
+			case "vs.VlanControl: ONUCVlan":
+				vs.VlanControl = ONUCVlan
+				if err := vs.setUSMatchActionVlanT0(tt.args.flow); (err != nil) != tt.wantErr {
+					t.Errorf("VoltService.setUSMatchActionVlanT0() error = %v, wantErr %v", err, tt.wantErr)
+				}
+			case "vs.VlanControl: ONUCVlan vs.UniVlan == of.VlanNone":
+				vs.VlanControl = ONUCVlan
+				vs.UniVlan = of.VlanNone
+				if err := vs.setUSMatchActionVlanT0(tt.args.flow); (err != nil) != tt.wantErr {
+					t.Errorf("VoltService.setUSMatchActionVlanT0() error = %v, wantErr %v", err, tt.wantErr)
+				}
+			case "vs.VlanControl: OLTSVlan":
+				vs.VlanControl = OLTSVlan
+				if err := vs.setUSMatchActionVlanT0(tt.args.flow); (err != nil) != tt.wantErr {
+					t.Errorf("VoltService.setUSMatchActionVlanT0() error = %v, wantErr %v", err, tt.wantErr)
+				}
+			}
+		})
+	}
+}
+
+func TestVoltService_setDSMatchActionVlanT1(t *testing.T) {
+	type args struct {
+		flow *of.VoltSubFlow
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		{
+			name: "vs.VlanControl: ONUCVlanOLTSVlan",
+			args: args{
+				flow: &of.VoltSubFlow{
+					ErrorReason: "test_error_reason",
+					Cookie:      uint64(1),
+					OldCookie:   uint64(2),
+					TableID:     uint32(3),
+					Priority:    uint32(4),
+					State:       uint8(5),
+				},
+			},
+		},
+		{
+			name: "vs.VlanControl: ONUCVlanOLTSVlan vs.UniVlan == of.VlanNone",
+			args: args{
+				flow: &of.VoltSubFlow{
+					ErrorReason: "test_error_reason",
+					Cookie:      uint64(1),
+					OldCookie:   uint64(2),
+					TableID:     uint32(3),
+					Priority:    uint32(4),
+					State:       uint8(5),
+				},
+			},
+		},
+		{
+			name: "vs.VlanControl: OLTCVlanOLTSVlan",
+			args: args{
+				flow: &of.VoltSubFlow{
+					ErrorReason: "test_error_reason",
+					Cookie:      uint64(1),
+					OldCookie:   uint64(2),
+					TableID:     uint32(3),
+					Priority:    uint32(4),
+					State:       uint8(5),
+				},
+			},
+		},
+		{
+			name: "vs.VlanControl: ONUCVlan",
+			args: args{
+				flow: &of.VoltSubFlow{
+					ErrorReason: "test_error_reason",
+					Cookie:      uint64(1),
+					OldCookie:   uint64(2),
+					TableID:     uint32(3),
+					Priority:    uint32(4),
+					State:       uint8(5),
+				},
+			},
+		},
+		{
+			name: "vs.VlanControl: ONUCVlan vs.UniVlan == of.VlanNone",
+			args: args{
+				flow: &of.VoltSubFlow{
+					ErrorReason: "test_error_reason",
+					Cookie:      uint64(1),
+					OldCookie:   uint64(2),
+					TableID:     uint32(3),
+					Priority:    uint32(4),
+					State:       uint8(5),
+				},
+			},
+		},
+		{
+			name: "vs.VlanControl: OLTSVlan",
+			args: args{
+				flow: &of.VoltSubFlow{
+					ErrorReason: "test_error_reason",
+					Cookie:      uint64(1),
+					OldCookie:   uint64(2),
+					TableID:     uint32(3),
+					Priority:    uint32(4),
+					State:       uint8(5),
+				},
+			},
+		},
+		{
+			name: "vs.VlanControl: default",
+			args: args{
+				flow: &of.VoltSubFlow{
+					ErrorReason: "test_error_reason",
+					Cookie:      uint64(1),
+					OldCookie:   uint64(2),
+					TableID:     uint32(3),
+					Priority:    uint32(4),
+					State:       uint8(5),
+				},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			vs := &VoltService{}
+			switch tt.name {
+			case "vs.VlanControl: ONUCVlanOLTSVlan":
+				vs.VlanControl = ONUCVlanOLTSVlan
+				if err := vs.setDSMatchActionVlanT1(tt.args.flow); (err != nil) != tt.wantErr {
+					t.Errorf("VoltService.setDSMatchActionVlanT1() error = %v, wantErr %v", err, tt.wantErr)
+				}
+			case "vs.VlanControl: ONUCVlanOLTSVlan vs.UniVlan == of.VlanNone":
+				vs.VlanControl = ONUCVlanOLTSVlan
+				vs.UniVlan = of.VlanNone
+				if err := vs.setDSMatchActionVlanT1(tt.args.flow); (err != nil) != tt.wantErr {
+					t.Errorf("VoltService.setDSMatchActionVlanT1() error = %v, wantErr %v", err, tt.wantErr)
+				}
+			case "vs.VlanControl: OLTCVlanOLTSVlan":
+				vs.VlanControl = OLTCVlanOLTSVlan
+				if err := vs.setDSMatchActionVlanT1(tt.args.flow); (err != nil) != tt.wantErr {
+					t.Errorf("VoltService.setDSMatchActionVlanT1() error = %v, wantErr %v", err, tt.wantErr)
+				}
+			case "vs.VlanControl: ONUCVlan":
+				vs.VlanControl = ONUCVlan
+				if err := vs.setDSMatchActionVlanT1(tt.args.flow); (err != nil) != tt.wantErr {
+					t.Errorf("VoltService.setDSMatchActionVlanT1() error = %v, wantErr %v", err, tt.wantErr)
+				}
+			case "vs.VlanControl: ONUCVlan vs.UniVlan == of.VlanNone":
+				vs.VlanControl = ONUCVlan
+				vs.UniVlan = of.VlanNone
+				if err := vs.setDSMatchActionVlanT1(tt.args.flow); (err != nil) != tt.wantErr {
+					t.Errorf("VoltService.setDSMatchActionVlanT1() error = %v, wantErr %v", err, tt.wantErr)
+				}
+			case "vs.VlanControl: OLTSVlan":
+				vs.VlanControl = OLTSVlan
+				if err := vs.setDSMatchActionVlanT1(tt.args.flow); (err != nil) != tt.wantErr {
+					t.Errorf("VoltService.setDSMatchActionVlanT1() error = %v, wantErr %v", err, tt.wantErr)
+				}
+			case "vs.VlanControl: default":
+				vs.VlanControl = 6
+				err := vs.setDSMatchActionVlanT1(tt.args.flow)
+				assert.NotNil(t, err)
+			}
+		})
+	}
+}
+
+func TestVoltService_SetIpv6Addr(t *testing.T) {
+	type args struct {
+		addr net.IP
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		{
+			name: "SetIpv6Addr",
+			args: args{
+				addr: AllSystemsMulticastGroupIP,
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			vs := &VoltService{}
+			vs.SetIpv6Addr(tt.args.addr)
+		})
+	}
+}
+
+func TestVoltService_SetIpv4Addr(t *testing.T) {
+	type args struct {
+		addr net.IP
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		{
+			name: "VoltService_SetIpv4Addr",
+			args: args{
+				addr: AllSystemsMulticastGroupIP,
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			vs := &VoltService{}
+			vs.SetIpv4Addr(tt.args.addr)
+		})
+	}
+}
+
+func TestVoltService_SetMacAddr(t *testing.T) {
+	type args struct {
+		addr net.HardwareAddr
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		{
+			name: "VoltService_SetMacAddr",
+			args: args{
+				addr: BroadcastMAC,
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			vs := &VoltService{}
+			vs.SetMacAddr(tt.args.addr)
+		})
+	}
+}
+
+func TestVoltService_GetCircuitID(t *testing.T) {
+	tests := []struct {
+		name string
+		want []byte
+	}{
+		{
+			name: "VoltService_GetCircuitID",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			vs := &VoltService{}
+			_ = vs.GetCircuitID()
+		})
+	}
+}
+
+func TestVoltService_GetRemoteID(t *testing.T) {
+	tests := []struct {
+		name string
+		want []byte
+	}{
+		{
+			name: "VoltService_GetRemoteID",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			vs := &VoltService{}
+			_ = vs.GetRemoteID()
+		})
+	}
+}
+
+func TestVoltService_IPAssigned(t *testing.T) {
+	tests := []struct {
+		name string
+		want bool
+	}{
+		{
+			name: "VoltService_IPAssigned",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			vs := &VoltService{}
+			_ = vs.IPAssigned()
+		})
+	}
+}