package nucleus

// import (
// 	"io"
// 	"reflect"
// 	"testing"

// 	ppb "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/pnd"
// 	tpb "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/transport"

// 	"code.fbi.h-da.de/danet/gosdn/controller/conflict"
// 	eventservice "code.fbi.h-da.de/danet/gosdn/controller/eventService"
// 	"code.fbi.h-da.de/danet/gosdn/controller/interfaces/networkdomain"
// 	"code.fbi.h-da.de/danet/gosdn/controller/interfaces/plugin"
// 	"code.fbi.h-da.de/danet/gosdn/controller/mocks"
// 	"code.fbi.h-da.de/danet/gosdn/controller/store"
// 	"github.com/google/uuid"
// 	gpb "github.com/openconfig/gnmi/proto/gnmi"
// 	"github.com/stretchr/testify/mock"
// )

// func TestNewPND(t *testing.T) {
// 	p, err := newPnd()
// 	if err != nil {
// 		t.Fatal(err)
// 		return
// 	}

// 	type args struct {
// 		name        string
// 		description string
// 		pid         uuid.UUID
// 	}
// 	tests := []struct {
// 		name    string
// 		args    args
// 		want    networkdomain.NetworkDomain
// 		wantErr bool
// 	}{
// 		{
// 			name: "default",
// 			args: args{
// 				name:        "default",
// 				description: "default test pnd",
// 				pid:         defaultPndID,
// 			},
// 			want:    p,
// 			wantErr: false,
// 		},
// 	}
// 	for _, tt := range tests {
// 		t.Run(tt.name, func(t *testing.T) {
// 			pluginService := NewPluginServiceMock()
// 			got, err := NewPND(tt.args.name, tt.args.description, tt.args.pid, nil, nil, pluginService, nil)
// 			if (err != nil) != tt.wantErr {
// 				t.Errorf("NewPND() error = %v, wantErr %v", err, tt.wantErr)
// 				return
// 			}
// 			if got.GetName() != tt.want.GetName() {
// 				t.Errorf("NewPND.GetName() = %v, want %v", got, tt.want)
// 			}
// 			if got.ID() != tt.want.ID() {
// 				t.Errorf("NewPND.ID() = %v, want %v", got, tt.want)
// 			}
// 			if got.GetDescription() != tt.want.GetDescription() {
// 				t.Errorf("NewPND.GetDescription() = %v, want %v", got, tt.want)
// 			}
// 		})
// 	}
// }

// func Test_pndImplementation_AddNetworkElement(t *testing.T) {
// 	type args struct {
// 		name            string
// 		opts            *tpb.TransportOption
// 		requestPluginFn func(uuid.UUID) (plugin.Plugin, error)
// 	}
// 	tests := []struct {
// 		name    string
// 		args    args
// 		wantErr bool
// 	}{
// 		{
// 			name: "default",
// 			args: args{
// 				name: "fridolin",
// 				opts: &tpb.TransportOption{
// 					TransportOption: &tpb.TransportOption_GnmiTransportOption{
// 						GnmiTransportOption: &tpb.GnmiTransportOption{},
// 					},
// 				},
// 				requestPluginFn: func(u uuid.UUID) (plugin.Plugin, error) {
// 					mockPlugin := &mocks.Plugin{}
// 					mockPlugin.On("ID").Return(u)
// 					mockPlugin.On("Model", mock.Anything).Return([]byte("mockModel"), nil)
// 					return mockPlugin, nil
// 				},
// 			},
// 			wantErr: false,
// 		},
// 	}
// 	for _, tt := range tests {
// 		t.Run(tt.name, func(t *testing.T) {
// 			mockPlugin := &mocks.Plugin{}
// 			mockPlugin.On("ID").Return(defaultPluginID)
// 			mockPlugin.On("Model", mock.Anything).Return([]byte("mockModel"), nil)
// 			mockPlugin.On("Unmarshal", mock.Anything, mock.Anything).Return(nil)

// 			pnd, err := newPnd()
// 			if err != nil {
// 				t.Fatal(err)
// 			}
// 			err = pnd.pluginService.Add(mockPlugin)
// 			if err != nil {
// 				t.Fatal(err)
// 			}

// 			_, err := pnd.AddNetworkElement(tt.args.name, tt.args.opts, tt.args.requestPluginFn, defaultPluginID, defaultPndID)
// 			if (err != nil) != tt.wantErr {
// 				t.Errorf("AddNetworkElement() error = %v, wantErr %v", err, tt.wantErr)
// 			}

// 			if tt.name != "fails wrong type" {
// 				if err == nil {
// 					mne, err := pnd.networkElementService.Get(store.Query{ID: defaultPndID})
// 					if err != nil {
// 						t.Errorf("AddNetworkElement() error = %v", err)
// 						return
// 					}
// 					if mne.Name() != tt.args.name {
// 						t.Errorf("AddNetworkElement() got = %v, want %v", mne.Name(), tt.args.name)
// 					}
// 					if err := pnd.networkElementService.Delete(mne); err != nil {
// 						t.Error(err)
// 					}
// 				}
// 			}
// 		})
// 	}
// }

// func Test_pndImplementation_GetDescription(t *testing.T) {
// 	tests := []struct {
// 		name string
// 		want string
// 	}{
// 		{name: "default", want: "default test pnd"},
// 	}
// 	for _, tt := range tests {
// 		t.Run(tt.name, func(t *testing.T) {
// 			pnd, err := newPnd()
// 			if err != nil {
// 				t.Errorf("GetDescription() = %v", err)
// 			}
// 			if got := pnd.GetDescription(); got != tt.want {
// 				t.Errorf("GetDescription() = %v, want %v", got, tt.want)
// 			}
// 		})
// 	}
// }

// func Test_pndImplementation_GetName(t *testing.T) {
// 	tests := []struct {
// 		name string
// 		want string
// 	}{
// 		{name: "default", want: "default"},
// 	}
// 	for _, tt := range tests {
// 		t.Run(tt.name, func(t *testing.T) {
// 			pnd, err := newPnd()
// 			if err != nil {
// 				t.Errorf("GetName() = %v", err)
// 			}
// 			if got := pnd.GetName(); got != tt.want {
// 				t.Errorf("GetName() = %v, want %v", got, tt.want)
// 			}
// 		})
// 	}
// }

// func Test_pndImplementation_MarshalNetworkElement(t *testing.T) {
// 	type args struct {
// 		uuid uuid.UUID
// 	}
// 	tests := []struct {
// 		name    string
// 		args    args
// 		want    string
// 		wantErr bool
// 	}{
// 		{
// 			name:    "default",
// 			want:    "{\n\t\"Acl\": null,\n\t\"Bfd\": null,\n\t\"Components\": null,\n\t\"Interfaces\": null,\n\t\"Keychains\": null,\n\t\"Lldp\": null,\n\t\"Messages\": null,\n\t\"NetworkInstances\": null,\n\t\"RoutingPolicy\": null,\n\t\"System\": null\n}",
// 			args:    args{mdid},
// 			wantErr: false,
// 		},
// 	}

// 	for _, tt := range tests {
// 		t.Run(tt.name, func(t *testing.T) {
// 			pnd, err := newPnd()
// 			if err != nil {
// 				t.Error(err)
// 			}

// 			mne := mockNetworkElement()

// 			_, err = pnd.addNetworkElement(mne)
// 			if err != nil {
// 				t.Error(err)
// 			}
// 			got, err := pnd.MarshalNetworkElement(tt.args.uuid.String())
// 			if (err != nil) != tt.wantErr {
// 				t.Errorf("MarshalNetworkElement() error = %v, wantErr %v", err, tt.wantErr)
// 				return
// 			}
// 			if got != tt.want {
// 				t.Errorf("MarshalNetworkElement() got = %v, want %v", got, tt.want)
// 			}
// 			if err := pnd.networkElementService.Delete(mne); err != nil {
// 				t.Error(err)
// 			}
// 		})
// 	}
// }

// func Test_pndImplementation_RemoveNetworkElement(t *testing.T) {
// 	type args struct {
// 		uuid                 uuid.UUID
// 		networkElementLength int
// 	}
// 	tests := []struct {
// 		name    string
// 		args    args
// 		wantErr bool
// 	}{
// 		{name: "default", args: args{uuid: mdid, networkElementLength: 0}, wantErr: false},
// 		{name: "fails", args: args{uuid: uuid.New(), networkElementLength: 1}, wantErr: true},
// 	}

// 	for _, tt := range tests {
// 		tt := tt
// 		t.Run(tt.name, func(t *testing.T) {
// 			t.Parallel()
// 			pnd, err := newPnd()
// 			if err != nil {
// 				t.Error(err)
// 			}

// 			mne := mockNetworkElement()

// 			_, err = pnd.addNetworkElement(mne)
// 			if err != nil {
// 				t.Error(err)
// 			}
// 			if err := pnd.RemoveNetworkElement(tt.args.uuid); (err != nil) != tt.wantErr {
// 				t.Errorf("RemoveNetworkElement() error = %v, wantErr %v", err, tt.wantErr)
// 			}
// 			ne, err := pnd.networkElementService.GetAll()
// 			if err != nil {
// 				t.Errorf("RemoveNetworkElement() error = %v, wantErr %v", err, tt.wantErr)
// 			}
// 			if len(ne) != tt.args.networkElementLength {
// 				t.Errorf("RemoveNetworkElement() error = length of network is: %v, want: %v", len(ne), tt.args.networkElementLength)
// 			}
// 		})
// 	}
// }

// // func Test_pndImplementation_Request(t *testing.T) {
// // 	type args struct {
// // 		uuid uuid.UUID
// // 		path string
// // 		rErr error
// // 	}
// // 	tests := []struct {
// // 		name    string
// // 		args    args
// // 		wantErr bool
// // 	}{
// // 		{
// // 			name: "default",
// // 			args: args{
// // 				uuid: mdid,
// // 				path: "",
// // 				rErr: nil,
// // 			},
// // 			wantErr: false,
// // 		},
// // 		{
// // 			name: "error",
// // 			args: args{
// // 				uuid: mneid,
// // 				path: "",
// // 				rErr: errors.New("deliberate test fail"),
// // 			},
// // 			wantErr: true,
// // 		},
// // 	}

// 	for _, tt := range tests {
// 		tt := tt
// 		t.Run(tt.name, func(t *testing.T) {
// 			t.Parallel()
// 			pluginService := NewPluginServiceMock()
// 			networkElementService := NewNetworkElementServiceMock()

// 			pnd := pndImplementation{
// 				Name:                  "default",
// 				Description:           "default test pnd",
// 				pluginService:         pluginService,
// 				networkElementService: networkElementService,
// 				changes:               store.NewChangeStore(),
// 				Id:                    defaultPndID,
// 			}

// 			transport := mocks.Transport{}
// 			transport.On("Get", mockContext, mock.Anything).Return(&gpb.GetResponse{}, tt.args.rErr)
// 			transport.On("ProcessResponse", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.rErr)

// 			networkElementWithMockTransport := &CommonNetworkElement{
// 				UUID:      mdid,
// 				Plugin:    mockPlugin(t),
// 				transport: &transport,
// 			}

// // 			_, _ = pnd.addNetworkElement(networkElementWithMockTransport)

// 			_, err := pnd.Request(tt.args.uuid, tt.args.path)
// 			if (err != nil) != tt.wantErr {
// 				t.Errorf("Request() error = %v, wantErr %v", err, tt.wantErr)
// 			}

// // 			mne, _ := pnd.networkElementService.Get(store.Query{ID: mdid})
// // 			if mne == nil {
// // 				return
// // 			}
// // 			if err := pnd.networkElementService.Delete(mne); err != nil {
// // 				t.Error(err)
// // 			}
// // 		})
// // 	}
// // }

// // func Test_pndImplementation_RequestAll(t *testing.T) {
// // 	type args struct {
// // 		uuid uuid.UUID
// // 		path string
// // 		rErr error
// // 	}
// // 	tests := []struct {
// // 		name    string
// // 		args    args
// // 		wantErr bool
// // 	}{
// // 		{
// // 			name: "default",
// // 			args: args{
// // 				uuid: mdid,
// // 				path: "",
// // 				rErr: nil,
// // 			},
// // 			wantErr: false,
// // 		},
// // 		{
// // 			name: "error",
// // 			args: args{
// // 				uuid: mneid,
// // 				path: "",
// // 				rErr: errors.New("deliberate test fail"),
// // 			},
// // 			wantErr: true,
// // 		},
// // 	}

// 	for _, tt := range tests {
// 		tt := tt
// 		t.Run(tt.name, func(t *testing.T) {
// 			t.Parallel()
// 			pluginService := NewPluginServiceMock()
// 			networkElementService := NewNetworkElementServiceMock()

// 			pnd := pndImplementation{
// 				Name:                  "default",
// 				Description:           "default test pnd",
// 				pluginService:         pluginService,
// 				networkElementService: networkElementService,
// 				changes:               store.NewChangeStore(),
// 				Id:                    defaultPndID,
// 			}

// 			transport := mocks.Transport{}
// 			transport.On("Get", mockContext, mock.Anything).Return(&gpb.GetResponse{}, tt.args.rErr)
// 			transport.On("ProcessResponse", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.rErr)

// 			networkElementWithMockTransport := &CommonNetworkElement{
// 				UUID:      mdid,
// 				Plugin:    mockPlugin(t),
// 				transport: &transport,
// 			}

// // 			_, _ = pnd.addNetworkElement(networkElementWithMockTransport)

// // 			mne, _ := pnd.networkElementService.Get(store.Query{ID: mdid})
// // 			if mne == nil {
// // 				return
// // 			}
// // 			if err := pnd.networkElementService.Delete(mne); err != nil {
// // 				t.Error(err)
// // 			}
// // 		})
// // 	}
// // }

// //func Test_pndImplementation_ChangeMNE(t *testing.T) {
// //	opts := &tpb.TransportOption{
// //		TransportOption: &tpb.TransportOption_GnmiTransportOption{
// //			GnmiTransportOption: &tpb.GnmiTransportOption{},
// //		},
// //	}
// //	type args struct {
// //		operation ppb.ApiOperation
// //		path      string
// //		value     []string
// //	}
// //	tests := []struct {
// //		name    string
// //		args    args
// //		wantErr bool
// //	}{
// //		{
// //			name: "update",
// //			args: args{
// //				operation: ppb.ApiOperation_API_OPERATION_UPDATE,
// //				path:      "/system/config/hostname",
// //				value:     []string{"ceos3000"},
// //			},
// //			wantErr: false,
// //		},
// //		{
// //			name: "replace",
// //			args: args{
// //				operation: ppb.ApiOperation_API_OPERATION_REPLACE,
// //				path:      "/system/config/hostname",
// //				value:     []string{"ceos3000"},
// //			},
// //			wantErr: false,
// //		},
// //		{
// //			name: "delete",
// //			args: args{
// //				operation: ppb.ApiOperation_API_OPERATION_DELETE,
// //				path:      "/system/config/hostname",
// //			},
// //			wantErr: false,
// //		},
// //		{
// //			name: "delete w/args",
// //			args: args{
// //				operation: ppb.ApiOperation_API_OPERATION_DELETE,
// //				path:      "/system/config/hostname",
// //				value:     []string{"ceos3000"},
// //			},
// //			wantErr: false,
// //		},
// //
// //		// Negative test cases
// //		{
// //			name: "invalid operation",
// //			args: args{
// //				operation: 54,
// //			},
// //			wantErr: true,
// //		},
// //		{
// //			name: "invalid arg count",
// //			args: args{
// //				operation: ppb.ApiOperation_API_OPERATION_UPDATE,
// //				path:      "/system/config/hostname",
// //				value:     []string{"ceos3000", "ceos3001"},
// //			},
// //			wantErr: true,
// //		},
// //		{
// //			name: "invalid arg count - update, no args",
// //			args: args{
// //				operation: ppb.ApiOperation_API_OPERATION_UPDATE,
// //				path:      "/system/config/hostname",
// //			},
// //			wantErr: true,
// //		},
// //		{
// //			name: "invalid arg count - replace, no args",
// //			args: args{
// //				operation: ppb.ApiOperation_API_OPERATION_UPDATE,
// //				path:      "/system/config/hostname",
// //			},
// //			wantErr: true,
// //		},
// //		{
// //			name: "network element not found",
// //			args: args{
// //				operation: ppb.ApiOperation_API_OPERATION_UPDATE,
// //			},
// //			wantErr: true,
// //		},
// //	}
// //	for _, tt := range tests {
// //		tt := tt
// //		t.Run(tt.name, func(t *testing.T) {
// //			t.Parallel()
// //			pnd := newPnd()
// //			_, err := pnd.AddNetworkElement("testnetworkElement", opts, defaultSbiID)
// //			if err != nil {
// //				t.Error(err)
// //				return
// //			}
// //
// //			networkElements, err := pnd.networkElementService.GetAllAsLoaded()
// //			if err != nil {
// //				err := errors.New("error fetching network element")
// //				t.Error(err)
// //				return
// //			}
// //
// //			neUUID, err := uuid.Parse(networkElements[0].ID)
// //			if err != nil {
// //				err := errors.New("error parsing network element uuid")
// //				t.Error(err)
// //				return
// //			}
// //
// //			_, err = pnd.ChangeMNE(neUUID, tt.args.operation, tt.args.path, tt.args.value...)
// //			if (err != nil) != tt.wantErr {
// //				t.Errorf("ChangeMNE() error = %v, wantErr %v", err, tt.wantErr)
// //				return
// //			}
// //			if !tt.wantErr {
// //				if len(pnd.changes.Store) != 1 {
// //					t.Errorf("ChangeMNE() unexpected change count. got %v, want 1", len(pnd.changes.Store))
// //				}
// //			}
// //		})
// //	}
// //}

// func Test_pndImplementation_GetNetworkElement(t *testing.T) {
// 	pnd, err := newPnd()
// 	if err != nil {
// 		t.Error(err)
// 		return
// 	}

// 	mne := mockNetworkElement()
// 	_, err = pnd.addNetworkElement(mne)
// 	if err != nil {
// 		t.Error(err)
// 		return
// 	}

// 	mPlugin, ok := mockPlugin(t).(plugin.Plugin)
// 	if !ok {
// 		t.Errorf("GetNetworkElement(), failed type conversion -> %v", &customerrs.InvalidTypeAssertionError{
// 			Value: mockPlugin(t),
// 			Type:  (*plugin.Plugin)(nil),
// 		})
// 		return
// 	}
// 	pluginModel, err := mPlugin.Model(false)
// 	if err != nil {
// 		t.Error(err)
// 		return
// 	}

// 	type args struct {
// 		uuid uuid.UUID
// 	}
// 	tests := []struct {
// 		name    string
// 		args    args
// 		want    []byte
// 		wantErr bool
// 	}{
// 		{
// 			name:    "default",
// 			args:    args{uuid: mdid},
// 			want:    pluginModel,
// 			wantErr: false,
// 		},
// 		{
// 			name:    "network element not found",
// 			args:    args{uuid: mneid},
// 			want:    nil,
// 			wantErr: true,
// 		},
// 	}
// 	for _, tt := range tests {
// 		tt := tt
// 		t.Run(tt.name, func(t *testing.T) {
// 			t.Parallel()
// 			foundNetworkElement, err := pnd.GetNetworkElement(tt.args.uuid.String())
// 			if (err != nil) != tt.wantErr {
// 				t.Errorf("GetNetworkElement() error = %v, wantErr %v", err, tt.wantErr)
// 				return
// 			}
// 			if foundNetworkElement != nil {
// 				model, err := foundNetworkElement.GetModel()
// 				if err != nil {
// 					t.Errorf("GetNetworkElement() error = %v, wantErr %v", err, tt.wantErr)
// 				}
// 				if !reflect.DeepEqual(model, tt.want) {
// 					t.Errorf("GetNetworkElement() got = %v, want %v", model, tt.want)
// 				}
// 			}
// 		})
// 	}
// }

// func Test_pndImplementation_GetNetworkElementByName(t *testing.T) {
// 	opts := &tpb.TransportOption{
// 		Address:  "",
// 		Username: "test",
// 		Password: "test",
// 		TransportOption: &tpb.TransportOption_GnmiTransportOption{
// 			GnmiTransportOption: &tpb.GnmiTransportOption{},
// 		},
// 	}

// 	pnd, err := newPnd()
// 	if err != nil {
// 		t.Error(err)
// 		return
// 	}
// 	mockPlugin := mockPlugin(t)
// 	pluginModel, err := mockPlugin.Model(false)
// 	if err != nil {
// 		t.Error(err)
// 		return
// 	}
// 	mne, err := NewNetworkElement("my-mne", mneid, opts, mockPlugin, conflict.Metadata{ResourceVersion: 0})
// 	if err != nil {
// 		t.Error(err)
// 		return
// 	}
// 	_, err = pnd.addNetworkElement(mne)
// 	if err != nil {
// 		t.Error(err)
// 		return
// 	}
// 	type args struct {
// 		name string
// 	}
// 	tests := []struct {
// 		name    string
// 		args    args
// 		want    []byte
// 		wantErr bool
// 	}{
// 		{
// 			name:    "default",
// 			args:    args{name: mne.Name()},
// 			want:    pluginModel,
// 			wantErr: false,
// 		},
// 		{
// 			name:    "network element not found",
// 			args:    args{name: "test-mne"},
// 			want:    nil,
// 			wantErr: true,
// 		},
// 	}
// 	for _, tt := range tests {
// 		tt := tt
// 		t.Run(tt.name, func(t *testing.T) {
// 			t.Parallel()
// 			foundNetworkElement, err := pnd.GetNetworkElement(tt.args.name)
// 			if (err != nil) != tt.wantErr {
// 				t.Errorf("GetNetworkElementByName() error = %v, wantErr %v", err, tt.wantErr)
// 				return
// 			}
// 			if foundNetworkElement != nil {
// 				model, err := foundNetworkElement.GetModel()
// 				if err != nil {
// 					t.Errorf("GetNetworkElement() error = %v, wantErr %v", err, tt.wantErr)
// 				}
// 				if !reflect.DeepEqual(model, tt.want) {
// 					t.Errorf("GetNetworkElementByName() got = %v, want %v", model, tt.want)
// 				}
// 			}
// 		})
// 	}
// }

// // func Test_pndImplementation_Confirm(t *testing.T) {
// // 	tests := []struct {
// // 		name    string
// // 		wantErr bool
// // 	}{
// // 		{
// // 			name:    "default",
// // 			wantErr: false,
// // 		},
// // 		{
// // 			name:    "uncommitted",
// // 			wantErr: true,
// // 		},
// // 	}

// 	for _, tt := range tests {
// 		t.Run(tt.name, func(t *testing.T) {
// 			pluginService := NewPluginServiceMock()
// 			networkElementService := NewNetworkElementServiceMock()

// 			pnd := pndImplementation{
// 				Name:                  "default",
// 				Description:           "default test pnd",
// 				pluginService:         pluginService,
// 				networkElementService: networkElementService,
// 				changes:               store.NewChangeStore(),
// 				Id:                    defaultPndID,
// 			}

// 			mne := mockNetworkElement()
// 			mockPlugin, ok := mne.GetPlugin().(*mocks.Plugin)
// 			if !ok {
// 				t.Errorf("Confirm(), failed type conversion -> %v", &customerrs.InvalidTypeAssertionError{
// 					Value: mne.GetPlugin(),
// 					Type:  (*mocks.Plugin)(nil),
// 				})
// 				return
// 			}
// 			mockPlugin.On("ValidateChange", mock.Anything, mock.Anything, mock.Anything).Return([]byte{}, nil)
// 			mockPlugin.On("PruneConfigFalse", mock.Anything).Return([]byte{}, nil)
// 			mockPlugin.On("Diff", mock.Anything, mock.Anything, mock.Anything).Return(&gpb.Notification{}, nil)
// 			tr, ok := mne.Transport().(*mocks.Transport)
// 			if !ok {
// 				t.Errorf("Confirm(), failed type conversion -> %v", &customerrs.InvalidTypeAssertionError{
// 					Value: mne.Transport(),
// 					Type:  (*mocks.Transport)(nil),
// 				})
// 				return
// 			}

// 			tr.On("Set", mockContext, mock.Anything, mock.Anything, mock.Anything).Return(nil)
// 			_, err := pnd.addNetworkElement(mne)
// 			if err != nil {
// 				t.Error(err)
// 				return
// 			}
// 			u, err := pnd.ChangeMNE(mne.ID(), ppb.ApiOperation_API_OPERATION_UPDATE, "system/config/hostname", "ceos3000")
// 			if err != nil {
// 				t.Error(err)
// 				return
// 			}
// 			if tt.name != "uncommitted" {
// 				if err := pnd.Commit(u); (err != nil) != tt.wantErr {
// 					t.Errorf("Confirm() error = %v, wantErr %v", err, tt.wantErr)
// 					return
// 				}
// 			}
// 			if err := pnd.Confirm(u); (err != nil) != tt.wantErr {
// 				t.Errorf("Confirm() error = %v, wantErr %v", err, tt.wantErr)
// 			}
// 		})
// 	}
// }

// //func Test_pndImplementation_PendingChanges(t *testing.T) {
// //	testName := t.Name()
// //	callback := func(first ygot.GoStruct, second ygot.GoStruct) error {
// //		log.Infof("callback in test %v", testName)
// //		return nil
// //	}
// //
// //	store := store.NewChangeStore()
// //	pending := NewChange(mneid, &openconfig.Device{}, &openconfig.Device{}, callback)
// //	if err := store.Add(pending); err != nil {
// //		t.Error(err)
// //		return
// //	}
// //	tests := []struct {
// //		name string
// //		want []uuid.UUID
// //	}{
// //		{
// //			name: "default",
// //			want: []uuid.UUID{pending.cuid},
// //		},
// //	}
// //	for _, tt := range tests {
// //		t.Run(tt.name, func(t *testing.T) {
// //			pnd := newPnd()
// //			pnd.changes = store
// //			if got := pnd.PendingChanges(); !reflect.DeepEqual(got, tt.want) {
// //				t.Errorf("pndImplementation.PendingChanges() = %v, want %v", got, tt.want)
// //			}
// //		})
// //	}
// //}
// //
// //func Test_pndImplementation_CommittedChanges(t *testing.T) {
// //	testName := t.Name()
// //	callback := func(first ygot.GoStruct, second ygot.GoStruct) error {
// //		log.Infof("callback in test %v", testName)
// //		return nil
// //	}
// //
// //	store := store.NewChangeStore()
// //	committed := NewChange(mneid, &openconfig.Device{}, &openconfig.Device{}, callback)
// //	if err := committed.Commit(); err != nil {
// //		t.Error(err)
// //		return
// //	}
// //	if err := store.Add(committed); err != nil {
// //		t.Error(err)
// //		return
// //	}
// //	tests := []struct {
// //		name string
// //		want []uuid.UUID
// //	}{
// //		{
// //			name: "default",
// //			want: []uuid.UUID{committed.cuid},
// //		},
// //	}
// //	for _, tt := range tests {
// //		t.Run(tt.name, func(t *testing.T) {
// //			pnd := newPnd()
// //			pnd.changes = store
// //			if got := pnd.CommittedChanges(); !reflect.DeepEqual(got, tt.want) {
// //				t.Errorf("pndImplementation.CommittedChanges() = %v, want %v", got, tt.want)
// //			}
// //		})
// //	}
// //}
// //
// //func Test_pndImplementation_ConfirmedChanges(t *testing.T) {
// //	testName := t.Name()
// //	callback := func(first ygot.GoStruct, second ygot.GoStruct) error {
// //		log.Infof("callback in test %v", testName)
// //		return nil
// //	}
// //	store := store.NewChangeStore()
// //	confirmed := NewChange(mneid, &openconfig.Device{}, &openconfig.Device{}, callback)
// //	if err := confirmed.Commit(); err != nil {
// //		t.Error(err)
// //		return
// //	}
// //	if err := confirmed.Confirm(); err != nil {
// //		t.Error(err)
// //		return
// //	}
// //	if err := store.Add(confirmed); err != nil {
// //		t.Error(err)
// //		return
// //	}
// //	tests := []struct {
// //		name string
// //		want []uuid.UUID
// //	}{
// //		{
// //			name: "default",
// //			want: []uuid.UUID{confirmed.cuid},
// //		},
// //	}
// //	for _, tt := range tests {
// //		t.Run(tt.name, func(t *testing.T) {
// //			pnd := newPnd()
// //			pnd.changes = store
// //			if got := pnd.ConfirmedChanges(); !reflect.DeepEqual(got, tt.want) {
// //				t.Errorf("pndImplementation.ConfirmedChanges() = %v, want %v", got, tt.want)
// //			}
// //		})
// //	}
// //}
// //
// //func Test_pndImplementation_saveStreamToFile(t *testing.T) {
// //	defer removeTestGoStructs()
// //
// //	type genericGoStructClientArg struct {
// //		fn    string
// //		rtrn  []interface{}
// //		times int
// //	}
// //	// Create a new mock for GenericGoStructClient. With
// //	// genericGoStructClientArg it is possible to set the Return values of the
// //	// mocks methods.
// //	newGenericGoStructClient := func(args ...genericGoStructClientArg) *mocks.GenericGoStructClient {
// //		ggsc := &mocks.GenericGoStructClient{}
// //		for _, arg := range args {
// //			ggsc.On(arg.fn).Return(arg.rtrn...).Times(arg.times)
// //		}
// //		ggsc.On("CloseSend").Return(nil)
// //		return ggsc
// //	}
// //
// //	type args struct {
// //		id     uuid.UUID
// //		client StreamClient
// //	}
// //	tests := []struct {
// //		name    string
// //		args    args
// //		wantErr bool
// //	}{
// //		{
// //			name: "default",
// //			args: args{
// //				id: uuid.New(),
// //				client: newGenericGoStructClient(
// //					[]genericGoStructClientArg{
// //						{
// //							fn: "Recv",
// //							rtrn: []interface{}{
// //								&csbi.Payload{Chunk: []byte("test")},
// //								nil,
// //							},
// //							times: 3,
// //						},
// //						{
// //							fn: "Recv",
// //							rtrn: []interface{}{
// //								&csbi.Payload{Chunk: nil},
// //								io.EOF,
// //							},
// //							times: 1,
// //						},
// //					}...),
// //			},
// //			wantErr: false,
// //		},
// //		{
// //			name: "unexpected EOF error",
// //			args: args{
// //				id: uuid.New(),
// //				client: newGenericGoStructClient(
// //					[]genericGoStructClientArg{
// //						{
// //							fn: "Recv",
// //							rtrn: []interface{}{
// //								&csbi.Payload{Chunk: nil},
// //								io.ErrUnexpectedEOF,
// //							},
// //							times: 1,
// //						},
// //						{
// //							fn: "CloseSend",
// //							rtrn: []interface{}{
// //								nil,
// //							},
// //							times: 1,
// //						},
// //					}...),
// //			},
// //			wantErr: true,
// //		},
// //	}
// //	var wg sync.WaitGroup
// //	for _, tt := range tests {
// //		wg.Add(1)
// //		tt := tt
// //
// //		// waitgroup and extra func needed to be able to clean up generated pnd directories while running test cases in parallel mode,
// //		// var x is just a dummy to be able to call the func,
// //		// outer t.Run() required for defered wg.Done().
// //		// reference: https://stackoverflow.com/a/63609718
// //		x := func() {
// //			defer wg.Done()
// //			t.Run("parallel waiting func", func(t *testing.T) {
// //				t.Run(tt.name, func(t *testing.T) {
// //					t.Parallel()
// //					err := saveStreamToFile(tt.args.client, util.GoStructName, tt.args.id)
// //					if (err != nil) != tt.wantErr {
// //						t.Errorf("saveGoStructsToFile() error = %v, wantErr %v", err, tt.wantErr)
// //					}
// //				})
// //			})
// //		}
// //		x()
// //	}
// //	wg.Wait()
// //}
