github.com/enbility/spine-go@v0.7.0/model/electricalconnection_additions_test.go (about)

     1  package model
     2  
     3  import (
     4  	"encoding/json"
     5  	"testing"
     6  
     7  	"github.com/enbility/spine-go/util"
     8  	"github.com/stretchr/testify/assert"
     9  )
    10  
    11  func TestElectricalConnectionStateListDataType_Update(t *testing.T) {
    12  	sut := ElectricalConnectionStateListDataType{
    13  		ElectricalConnectionStateData: []ElectricalConnectionStateDataType{
    14  			{
    15  				ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(0)),
    16  				CurrentEnergyMode:      util.Ptr(EnergyModeTypeProduce),
    17  			},
    18  			{
    19  				ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(1)),
    20  				CurrentEnergyMode:      util.Ptr(EnergyModeTypeProduce),
    21  			},
    22  		},
    23  	}
    24  
    25  	newData := ElectricalConnectionStateListDataType{
    26  		ElectricalConnectionStateData: []ElectricalConnectionStateDataType{
    27  			{
    28  				ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(1)),
    29  				CurrentEnergyMode:      util.Ptr(EnergyModeTypeConsume),
    30  			},
    31  		},
    32  	}
    33  
    34  	// Act
    35  	_, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil)
    36  	assert.True(t, success)
    37  
    38  	data := sut.ElectricalConnectionStateData
    39  	// check the non changing items
    40  	assert.Equal(t, 2, len(data))
    41  	item1 := data[0]
    42  	assert.Equal(t, 0, int(*item1.ElectricalConnectionId))
    43  	assert.Equal(t, EnergyModeTypeProduce, *item1.CurrentEnergyMode)
    44  	// check properties of updated item
    45  	item2 := data[1]
    46  	assert.Equal(t, 1, int(*item2.ElectricalConnectionId))
    47  	assert.Equal(t, EnergyModeTypeConsume, *item2.CurrentEnergyMode)
    48  }
    49  
    50  // verifies that a subset of existing items will be updated with identified new values
    51  func TestElectricalConnectionPermittedValueSetListDataType_Update_Modify(t *testing.T) {
    52  	sut := ElectricalConnectionPermittedValueSetListDataType{
    53  		ElectricalConnectionPermittedValueSetData: []ElectricalConnectionPermittedValueSetDataType{
    54  			{
    55  				ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(0)),
    56  				ParameterId:            util.Ptr(ElectricalConnectionParameterIdType(0)),
    57  				PermittedValueSet: []ScaledNumberSetType{
    58  					{
    59  						Range: []ScaledNumberRangeType{
    60  							{
    61  								Min: NewScaledNumberType(1),
    62  							},
    63  						},
    64  					},
    65  				},
    66  			},
    67  			{
    68  				ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(0)),
    69  				ParameterId:            util.Ptr(ElectricalConnectionParameterIdType(1)),
    70  				PermittedValueSet: []ScaledNumberSetType{
    71  					{
    72  						Range: []ScaledNumberRangeType{
    73  							{
    74  								Min: NewScaledNumberType(6),
    75  								Max: NewScaledNumberType(16),
    76  							},
    77  						},
    78  					},
    79  				},
    80  			},
    81  			{
    82  				ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(0)),
    83  				ParameterId:            util.Ptr(ElectricalConnectionParameterIdType(2)),
    84  				PermittedValueSet: []ScaledNumberSetType{
    85  					{
    86  						Range: []ScaledNumberRangeType{
    87  							{
    88  								Min: NewScaledNumberType(6),
    89  								Max: NewScaledNumberType(16),
    90  							},
    91  						},
    92  					},
    93  				},
    94  			},
    95  			{
    96  				ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(0)),
    97  				ParameterId:            util.Ptr(ElectricalConnectionParameterIdType(3)),
    98  				PermittedValueSet: []ScaledNumberSetType{
    99  					{
   100  						Range: []ScaledNumberRangeType{
   101  							{
   102  								Min: NewScaledNumberType(6),
   103  								Max: NewScaledNumberType(16),
   104  							},
   105  						},
   106  					},
   107  				},
   108  			},
   109  		},
   110  	}
   111  
   112  	newData := ElectricalConnectionPermittedValueSetListDataType{
   113  		ElectricalConnectionPermittedValueSetData: []ElectricalConnectionPermittedValueSetDataType{
   114  			{
   115  				ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(0)),
   116  				ParameterId:            util.Ptr(ElectricalConnectionParameterIdType(1)),
   117  				PermittedValueSet: []ScaledNumberSetType{
   118  					{
   119  						Range: []ScaledNumberRangeType{
   120  							{
   121  								Min: NewScaledNumberType(2),
   122  								Max: NewScaledNumberType(16),
   123  							},
   124  						},
   125  					},
   126  				},
   127  			},
   128  			{
   129  				ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(0)),
   130  				ParameterId:            util.Ptr(ElectricalConnectionParameterIdType(2)),
   131  				PermittedValueSet: []ScaledNumberSetType{
   132  					{
   133  						Range: []ScaledNumberRangeType{
   134  							{
   135  								Min: NewScaledNumberType(2),
   136  								Max: NewScaledNumberType(16),
   137  							},
   138  						},
   139  					},
   140  				},
   141  			},
   142  			{
   143  				ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(0)),
   144  				ParameterId:            util.Ptr(ElectricalConnectionParameterIdType(3)),
   145  				PermittedValueSet: []ScaledNumberSetType{
   146  					{
   147  						Range: []ScaledNumberRangeType{
   148  							{
   149  								Min: NewScaledNumberType(2),
   150  								Max: NewScaledNumberType(16),
   151  							},
   152  						},
   153  					},
   154  				},
   155  			},
   156  		},
   157  	}
   158  
   159  	// Act
   160  	_, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil)
   161  	assert.True(t, success)
   162  
   163  	data := sut.ElectricalConnectionPermittedValueSetData
   164  	// check the non changing items
   165  	assert.Equal(t, 4, len(data))
   166  	item1 := data[0]
   167  	assert.Equal(t, 0, int(*item1.ElectricalConnectionId))
   168  	assert.Equal(t, 0, int(*item1.ParameterId))
   169  	assert.Equal(t, 1, len(item1.PermittedValueSet))
   170  	// check properties of updated item
   171  	item2 := data[1]
   172  	assert.Equal(t, 0, int(*item2.ElectricalConnectionId))
   173  	assert.Equal(t, 1, int(*item2.ParameterId))
   174  	assert.Equal(t, 1, len(item2.PermittedValueSet))
   175  	valueSet := item2.PermittedValueSet[0]
   176  	assert.Equal(t, 1, len(valueSet.Range))
   177  	rangeSet := valueSet.Range[0]
   178  	assert.Equal(t, 2.0, rangeSet.Min.GetValue())
   179  	assert.Equal(t, 16.0, rangeSet.Max.GetValue())
   180  }
   181  
   182  // verifies that a subset of existing items will be updated with identified new values
   183  func TestElectricalConnectionPermittedValueSetListDataType_Update_Modify_Selector(t *testing.T) {
   184  	existingDataJson := `{
   185  		"electricalConnectionPermittedValueSetData":[
   186  			{
   187  				"electricalConnectionId":0,
   188  				"parameterId":0,
   189  				"permittedValueSet":[
   190  					{
   191  						"range":[
   192  							{
   193  								"min":{"number":1,"scale":0}
   194  							}
   195  						]
   196  					}
   197  				]
   198  			},
   199  			{
   200  				"electricalConnectionId":0,
   201  				"parameterId":1,
   202  				"permittedValueSet":[
   203  					{
   204  						"range":[
   205  							{
   206  								"min":{"number":6,"scale":0},
   207  								"max":{"number":16,"scale":0}
   208  							}
   209  						]
   210  					}
   211  				]
   212  			},
   213  			{
   214  				"electricalConnectionId":0,
   215  				"parameterId":2,
   216  				"permittedValueSet":[
   217  					{
   218  						"range":[
   219  							{
   220  								"min":{"number":6,"scale":0},
   221  								"max":{"number":16,"scale":0}
   222  							}
   223  						]
   224  					}
   225  				]
   226  			},
   227  			{
   228  				"electricalConnectionId":0,
   229  				"parameterId":3,
   230  				"permittedValueSet":[
   231  					{
   232  						"range":[
   233  							{
   234  								"min":{"number":6,"scale":0},
   235  								"max":{"number":16,"scale":0}
   236  							}
   237  						]
   238  					}
   239  				]
   240  			}
   241  		]
   242  	}`
   243  
   244  	var sut ElectricalConnectionPermittedValueSetListDataType
   245  	err := json.Unmarshal([]byte(existingDataJson), &sut)
   246  	if assert.Nil(t, err) == false {
   247  		return
   248  	}
   249  
   250  	newDataJson := `{
   251  		"electricalConnectionPermittedValueSetData":[
   252  			{
   253  				"permittedValueSet":[
   254  					{
   255  						"range":[
   256  							{
   257  								"min":{"number":2,"scale":0},
   258  								"max":{"number":16,"scale":0}
   259  							}
   260  						]
   261  					}
   262  				]
   263  			}
   264  		]
   265  	}`
   266  
   267  	var newData ElectricalConnectionPermittedValueSetListDataType
   268  	err = json.Unmarshal([]byte(newDataJson), &newData)
   269  	if assert.Nil(t, err) == false {
   270  		return
   271  	}
   272  
   273  	partial := &FilterType{
   274  		CmdControl: &CmdControlType{
   275  			Partial: &ElementTagType{},
   276  		},
   277  		ElectricalConnectionPermittedValueSetListDataSelectors: &ElectricalConnectionPermittedValueSetListDataSelectorsType{
   278  			ElectricalConnectionId: util.Ptr[ElectricalConnectionIdType](0),
   279  			ParameterId:            util.Ptr[ElectricalConnectionParameterIdType](1),
   280  		},
   281  	}
   282  
   283  	// Act
   284  	_, success := sut.UpdateList(false, false, &newData, partial, nil)
   285  	assert.True(t, success)
   286  
   287  	data := sut.ElectricalConnectionPermittedValueSetData
   288  	// check the non changing items
   289  	assert.Equal(t, 4, len(data))
   290  	item1 := data[0]
   291  	assert.Equal(t, 0, int(*item1.ElectricalConnectionId))
   292  	assert.Equal(t, 0, int(*item1.ParameterId))
   293  	assert.Equal(t, 1, len(item1.PermittedValueSet))
   294  	item3 := data[2]
   295  	assert.Equal(t, 0, int(*item3.ElectricalConnectionId))
   296  	assert.Equal(t, 2, int(*item3.ParameterId))
   297  	assert.Equal(t, 1, len(item3.PermittedValueSet))
   298  	valueSet := item3.PermittedValueSet[0]
   299  	assert.Equal(t, 1, len(valueSet.Range))
   300  	rangeSet := valueSet.Range[0]
   301  	assert.Equal(t, 6.0, rangeSet.Min.GetValue())
   302  	assert.Equal(t, 16.0, rangeSet.Max.GetValue())
   303  
   304  	// check properties of updated item
   305  	item2 := sut.ElectricalConnectionPermittedValueSetData[1]
   306  	assert.Equal(t, 0, int(*item2.ElectricalConnectionId))
   307  	assert.Equal(t, 1, int(*item2.ParameterId))
   308  	assert.Equal(t, 1, len(item2.PermittedValueSet))
   309  	valueSet = item2.PermittedValueSet[0]
   310  	assert.Equal(t, 1, len(valueSet.Range))
   311  	rangeSet = valueSet.Range[0]
   312  	assert.Equal(t, 2.0, rangeSet.Min.GetValue())
   313  	assert.Equal(t, 16.0, rangeSet.Max.GetValue())
   314  }
   315  
   316  // verifies that a subset of existing items will be updated with identified new values
   317  func TestElectricalConnectionPermittedValueSetListDataType_Update_Delete_Modify(t *testing.T) {
   318  	existingDataJson := `{
   319  		"electricalConnectionPermittedValueSetData":[
   320  			{
   321  				"electricalConnectionId":0,
   322  				"parameterId":0,
   323  				"permittedValueSet":[
   324  					{
   325  						"range":[
   326  							{
   327  								"min":{"number":1,"scale":0}
   328  							}
   329  						]
   330  					}
   331  				]
   332  			},
   333  			{
   334  				"electricalConnectionId":0,
   335  				"parameterId":1,
   336  				"permittedValueSet":[
   337  					{
   338  						"range":[
   339  							{
   340  								"min":{"number":6,"scale":0},
   341  								"max":{"number":16,"scale":0}
   342  							}
   343  						]
   344  					}
   345  				]
   346  			},
   347  			{
   348  				"electricalConnectionId":0,
   349  				"parameterId":2,
   350  				"permittedValueSet":[
   351  					{
   352  						"range":[
   353  							{
   354  								"min":{"number":6,"scale":0},
   355  								"max":{"number":16,"scale":0}
   356  							}
   357  						]
   358  					}
   359  				]
   360  			},
   361  			{
   362  				"electricalConnectionId":0,
   363  				"parameterId":3,
   364  				"permittedValueSet":[
   365  					{
   366  						"range":[
   367  							{
   368  								"min":{"number":6,"scale":0},
   369  								"max":{"number":16,"scale":0}
   370  							}
   371  						]
   372  					}
   373  				]
   374  			}
   375  		]
   376  	}`
   377  
   378  	var sut ElectricalConnectionPermittedValueSetListDataType
   379  	err := json.Unmarshal([]byte(existingDataJson), &sut)
   380  	if assert.Nil(t, err) == false {
   381  		return
   382  	}
   383  
   384  	newDataJson := `{
   385  		"electricalConnectionPermittedValueSetData":[
   386  			{
   387  				"electricalConnectionId":0,
   388  				"parameterId":1,
   389  				"permittedValueSet":[
   390  					{
   391  						"range":[
   392  							{
   393  								"min":{"number":2,"scale":0},
   394  								"max":{"number":16,"scale":0}
   395  							}
   396  						]
   397  					}
   398  				]
   399  			},
   400  			{
   401  				"electricalConnectionId":0,
   402  				"parameterId":2,
   403  				"permittedValueSet":[
   404  					{
   405  						"range":[
   406  							{
   407  								"min":{"number":2,"scale":0},
   408  								"max":{"number":16,"scale":0}
   409  							}
   410  						]
   411  					}
   412  				]
   413  			},
   414  			{
   415  				"electricalConnectionId":0,
   416  				"parameterId":3,
   417  				"permittedValueSet":[
   418  					{
   419  						"range":[
   420  							{
   421  								"min":{"number":2,"scale":0},
   422  								"max":{"number":16,"scale":0}
   423  							}
   424  						]
   425  					}
   426  				]
   427  			}
   428  		]
   429  	}`
   430  
   431  	var newData ElectricalConnectionPermittedValueSetListDataType
   432  	err = json.Unmarshal([]byte(newDataJson), &newData)
   433  	if assert.Nil(t, err) == false {
   434  		return
   435  	}
   436  
   437  	deleteFilter := &FilterType{
   438  		CmdControl: &CmdControlType{
   439  			Delete: &ElementTagType{},
   440  		},
   441  		ElectricalConnectionPermittedValueSetListDataSelectors: &ElectricalConnectionPermittedValueSetListDataSelectorsType{
   442  			ElectricalConnectionId: util.Ptr[ElectricalConnectionIdType](0),
   443  			ParameterId:            util.Ptr[ElectricalConnectionParameterIdType](0),
   444  		},
   445  	}
   446  
   447  	// Act
   448  	_, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), deleteFilter)
   449  	assert.True(t, success)
   450  
   451  	data := sut.ElectricalConnectionPermittedValueSetData
   452  	// check the deleted item is gone
   453  	assert.Equal(t, 3, len(data))
   454  	// check properties of updated item
   455  	item1 := data[0]
   456  	assert.Equal(t, 0, int(*item1.ElectricalConnectionId))
   457  	assert.Equal(t, 1, int(*item1.ParameterId))
   458  	assert.Equal(t, 1, len(item1.PermittedValueSet))
   459  	valueSet := item1.PermittedValueSet[0]
   460  	assert.Equal(t, 1, len(valueSet.Range))
   461  	rangeSet := valueSet.Range[0]
   462  	assert.Equal(t, 2.0, rangeSet.Min.GetValue())
   463  	assert.Equal(t, 16.0, rangeSet.Max.GetValue())
   464  }
   465  
   466  // verifies that a subset of existing items will be updated with identified new values
   467  func TestElectricalConnectionPermittedValueSetListDataType_Update_Delete(t *testing.T) {
   468  	existingDataJson := `{
   469  		"electricalConnectionPermittedValueSetData":[
   470  			{
   471  				"electricalConnectionId":0,
   472  				"parameterId":0,
   473  				"permittedValueSet":[
   474  					{
   475  						"range":[
   476  							{
   477  								"min":{"number":1,"scale":0}
   478  							}
   479  						]
   480  					}
   481  				]
   482  			},
   483  			{
   484  				"electricalConnectionId":0,
   485  				"parameterId":1,
   486  				"permittedValueSet":[
   487  					{
   488  						"range":[
   489  							{
   490  								"min":{"number":6,"scale":0},
   491  								"max":{"number":16,"scale":0}
   492  							}
   493  						]
   494  					}
   495  				]
   496  			},
   497  			{
   498  				"electricalConnectionId":0,
   499  				"parameterId":2,
   500  				"permittedValueSet":[
   501  					{
   502  						"range":[
   503  							{
   504  								"min":{"number":6,"scale":0},
   505  								"max":{"number":16,"scale":0}
   506  							}
   507  						]
   508  					}
   509  				]
   510  			},
   511  			{
   512  				"electricalConnectionId":0,
   513  				"parameterId":3,
   514  				"permittedValueSet":[
   515  					{
   516  						"range":[
   517  							{
   518  								"min":{"number":6,"scale":0},
   519  								"max":{"number":16,"scale":0}
   520  							}
   521  						]
   522  					}
   523  				]
   524  			}
   525  		]
   526  	}`
   527  
   528  	var sut ElectricalConnectionPermittedValueSetListDataType
   529  	err := json.Unmarshal([]byte(existingDataJson), &sut)
   530  	if assert.Nil(t, err) == false {
   531  		return
   532  	}
   533  
   534  	deleteFilter := &FilterType{
   535  		CmdControl: &CmdControlType{
   536  			Delete: &ElementTagType{},
   537  		},
   538  		ElectricalConnectionPermittedValueSetListDataSelectors: &ElectricalConnectionPermittedValueSetListDataSelectorsType{
   539  			ElectricalConnectionId: util.Ptr[ElectricalConnectionIdType](0),
   540  			ParameterId:            util.Ptr[ElectricalConnectionParameterIdType](0),
   541  		},
   542  	}
   543  
   544  	// Act
   545  	_, success := sut.UpdateList(false, true, nil, nil, deleteFilter)
   546  	assert.True(t, success)
   547  
   548  	data := sut.ElectricalConnectionPermittedValueSetData
   549  	// check the deleted item is added again
   550  	assert.Equal(t, 3, len(data))
   551  	// check properties of remaining item
   552  	item1 := data[0]
   553  	assert.Equal(t, 0, int(*item1.ElectricalConnectionId))
   554  	assert.Equal(t, 1, int(*item1.ParameterId))
   555  	assert.Equal(t, 1, len(item1.PermittedValueSet))
   556  	valueSet := item1.PermittedValueSet[0]
   557  	assert.Equal(t, 1, len(valueSet.Range))
   558  	rangeSet := valueSet.Range[0]
   559  	assert.Equal(t, 6.0, rangeSet.Min.GetValue())
   560  	assert.Equal(t, 16.0, rangeSet.Max.GetValue())
   561  }
   562  
   563  // verifies that a subset of existing items will be updated with identified new values
   564  func TestElectricalConnectionPermittedValueSetListDataType_Update_Delete_Element(t *testing.T) {
   565  	existingDataJson := `{
   566  		"electricalConnectionPermittedValueSetData":[
   567  			{
   568  				"electricalConnectionId":0,
   569  				"parameterId":0,
   570  				"permittedValueSet":[
   571  					{
   572  						"range":[
   573  							{
   574  								"min":{"number":1,"scale":0}
   575  							}
   576  						]
   577  					}
   578  				]
   579  			},
   580  			{
   581  				"electricalConnectionId":0,
   582  				"parameterId":1,
   583  				"permittedValueSet":[
   584  					{
   585  						"range":[
   586  							{
   587  								"min":{"number":6,"scale":0},
   588  								"max":{"number":16,"scale":0}
   589  							}
   590  						]
   591  					}
   592  				]
   593  			},
   594  			{
   595  				"electricalConnectionId":0,
   596  				"parameterId":2,
   597  				"permittedValueSet":[
   598  					{
   599  						"range":[
   600  							{
   601  								"min":{"number":6,"scale":0},
   602  								"max":{"number":16,"scale":0}
   603  							}
   604  						]
   605  					}
   606  				]
   607  			},
   608  			{
   609  				"electricalConnectionId":0,
   610  				"parameterId":3,
   611  				"permittedValueSet":[
   612  					{
   613  						"range":[
   614  							{
   615  								"min":{"number":6,"scale":0},
   616  								"max":{"number":16,"scale":0}
   617  							}
   618  						]
   619  					}
   620  				]
   621  			}
   622  		]
   623  	}`
   624  
   625  	var sut ElectricalConnectionPermittedValueSetListDataType
   626  	err := json.Unmarshal([]byte(existingDataJson), &sut)
   627  	if assert.Nil(t, err) == false {
   628  		return
   629  	}
   630  
   631  	deleteFilter := &FilterType{
   632  		CmdControl: &CmdControlType{
   633  			Delete: &ElementTagType{},
   634  		},
   635  		ElectricalConnectionPermittedValueSetDataElements: &ElectricalConnectionPermittedValueSetDataElementsType{
   636  			PermittedValueSet: &ElementTagType{},
   637  		},
   638  		ElectricalConnectionPermittedValueSetListDataSelectors: &ElectricalConnectionPermittedValueSetListDataSelectorsType{
   639  			ElectricalConnectionId: util.Ptr[ElectricalConnectionIdType](0),
   640  			ParameterId:            util.Ptr[ElectricalConnectionParameterIdType](0),
   641  		},
   642  	}
   643  
   644  	// Act
   645  	_, success := sut.UpdateList(false, true, nil, nil, deleteFilter)
   646  	assert.True(t, success)
   647  
   648  	data := sut.ElectricalConnectionPermittedValueSetData
   649  	// check no items are deleted
   650  	assert.Equal(t, 4, len(data))
   651  	// check permitted value is removed from item with ID 0
   652  	item1 := data[0]
   653  	assert.Equal(t, 0, int(*item1.ElectricalConnectionId))
   654  	assert.Equal(t, 0, int(*item1.ParameterId))
   655  	var nilValue []ScaledNumberSetType
   656  	assert.Equal(t, nilValue, item1.PermittedValueSet)
   657  
   658  	// check properties of remaining item
   659  	item2 := data[1]
   660  	assert.Equal(t, 0, int(*item2.ElectricalConnectionId))
   661  	assert.Equal(t, 1, int(*item2.ParameterId))
   662  	assert.Equal(t, 1, len(item2.PermittedValueSet))
   663  	valueSet := item2.PermittedValueSet[0]
   664  	assert.Equal(t, 1, len(valueSet.Range))
   665  	rangeSet := valueSet.Range[0]
   666  	assert.Equal(t, 6.0, rangeSet.Min.GetValue())
   667  	assert.Equal(t, 16.0, rangeSet.Max.GetValue())
   668  }
   669  
   670  // verifies that a subset of existing items will be updated with identified new values
   671  func TestElectricalConnectionPermittedValueSetListDataType_Update_Delete_OnlyElement(t *testing.T) {
   672  	existingDataJson := `{
   673  		"electricalConnectionPermittedValueSetData":[
   674  			{
   675  				"electricalConnectionId":0,
   676  				"parameterId":0,
   677  				"permittedValueSet":[
   678  					{
   679  						"range":[
   680  							{
   681  								"min":{"number":1,"scale":0}
   682  							}
   683  						]
   684  					}
   685  				]
   686  			},
   687  			{
   688  				"electricalConnectionId":0,
   689  				"parameterId":1,
   690  				"permittedValueSet":[
   691  					{
   692  						"range":[
   693  							{
   694  								"min":{"number":6,"scale":0},
   695  								"max":{"number":16,"scale":0}
   696  							}
   697  						]
   698  					}
   699  				]
   700  			},
   701  			{
   702  				"electricalConnectionId":0,
   703  				"parameterId":2,
   704  				"permittedValueSet":[
   705  					{
   706  						"range":[
   707  							{
   708  								"min":{"number":6,"scale":0},
   709  								"max":{"number":16,"scale":0}
   710  							}
   711  						]
   712  					}
   713  				]
   714  			},
   715  			{
   716  				"electricalConnectionId":0,
   717  				"parameterId":3,
   718  				"permittedValueSet":[
   719  					{
   720  						"range":[
   721  							{
   722  								"min":{"number":6,"scale":0},
   723  								"max":{"number":16,"scale":0}
   724  							}
   725  						]
   726  					}
   727  				]
   728  			}
   729  		]
   730  	}`
   731  
   732  	var sut ElectricalConnectionPermittedValueSetListDataType
   733  	err := json.Unmarshal([]byte(existingDataJson), &sut)
   734  	if assert.Nil(t, err) == false {
   735  		return
   736  	}
   737  
   738  	deleteFilter := &FilterType{
   739  		CmdControl: &CmdControlType{
   740  			Delete: &ElementTagType{},
   741  		},
   742  		ElectricalConnectionPermittedValueSetDataElements: &ElectricalConnectionPermittedValueSetDataElementsType{
   743  			PermittedValueSet: &ElementTagType{},
   744  		},
   745  	}
   746  
   747  	// Act
   748  	_, success := sut.UpdateList(false, true, nil, nil, deleteFilter)
   749  	assert.True(t, success)
   750  
   751  	data := sut.ElectricalConnectionPermittedValueSetData
   752  	// check no items are deleted
   753  	assert.Equal(t, 4, len(data))
   754  	// check permitted value is removed from item with ID 0
   755  	item1 := data[0]
   756  	assert.Equal(t, 0, int(*item1.ElectricalConnectionId))
   757  	assert.Equal(t, 0, int(*item1.ParameterId))
   758  	var nilValue []ScaledNumberSetType
   759  	assert.Equal(t, nilValue, item1.PermittedValueSet)
   760  
   761  	// check properties
   762  	item2 := data[1]
   763  	assert.Equal(t, 0, int(*item2.ElectricalConnectionId))
   764  	assert.Equal(t, 1, int(*item2.ParameterId))
   765  	assert.Equal(t, nilValue, item2.PermittedValueSet)
   766  
   767  	item3 := data[2]
   768  	assert.Equal(t, 0, int(*item3.ElectricalConnectionId))
   769  	assert.Equal(t, 2, int(*item3.ParameterId))
   770  	assert.Equal(t, nilValue, item3.PermittedValueSet)
   771  
   772  	item4 := data[3]
   773  	assert.Equal(t, 0, int(*item4.ElectricalConnectionId))
   774  	assert.Equal(t, 3, int(*item4.ParameterId))
   775  	assert.Equal(t, nilValue, item4.PermittedValueSet)
   776  }
   777  
   778  // verifies that a subset of existing items will be updated with identified new values
   779  func TestElectricalConnectionPermittedValueSetListDataType_Update_Delete_Add(t *testing.T) {
   780  	existingDataJson := `{
   781  		"electricalConnectionPermittedValueSetData":[
   782  			{
   783  				"electricalConnectionId":0,
   784  				"parameterId":0,
   785  				"permittedValueSet":[
   786  					{
   787  						"range":[
   788  							{
   789  								"min":{"number":1,"scale":0}
   790  							}
   791  						]
   792  					}
   793  				]
   794  			},
   795  			{
   796  				"electricalConnectionId":0,
   797  				"parameterId":1,
   798  				"permittedValueSet":[
   799  					{
   800  						"range":[
   801  							{
   802  								"min":{"number":6,"scale":0},
   803  								"max":{"number":16,"scale":0}
   804  							}
   805  						]
   806  					}
   807  				]
   808  			},
   809  			{
   810  				"electricalConnectionId":0,
   811  				"parameterId":2,
   812  				"permittedValueSet":[
   813  					{
   814  						"range":[
   815  							{
   816  								"min":{"number":6,"scale":0},
   817  								"max":{"number":16,"scale":0}
   818  							}
   819  						]
   820  					}
   821  				]
   822  			},
   823  			{
   824  				"electricalConnectionId":0,
   825  				"parameterId":3,
   826  				"permittedValueSet":[
   827  					{
   828  						"range":[
   829  							{
   830  								"min":{"number":6,"scale":0},
   831  								"max":{"number":16,"scale":0}
   832  							}
   833  						]
   834  					}
   835  				]
   836  			}
   837  		]
   838  	}`
   839  
   840  	var sut ElectricalConnectionPermittedValueSetListDataType
   841  	err := json.Unmarshal([]byte(existingDataJson), &sut)
   842  	if assert.Nil(t, err) == false {
   843  		return
   844  	}
   845  
   846  	newDataJson := `{
   847  		"electricalConnectionPermittedValueSetData":[
   848  			{
   849  				"electricalConnectionId":0,
   850  				"parameterId":0,
   851  				"permittedValueSet":[
   852  					{
   853  						"range":[
   854  							{
   855  								"min":{"number":1,"scale":0}
   856  							}
   857  						]
   858  					}
   859  				]
   860  			},
   861  			{
   862  				"electricalConnectionId":0,
   863  				"parameterId":1,
   864  				"permittedValueSet":[
   865  					{
   866  						"range":[
   867  							{
   868  								"min":{"number":2,"scale":0},
   869  								"max":{"number":16,"scale":0}
   870  							}
   871  						]
   872  					}
   873  				]
   874  			},
   875  			{
   876  				"electricalConnectionId":0,
   877  				"parameterId":2,
   878  				"permittedValueSet":[
   879  					{
   880  						"range":[
   881  							{
   882  								"min":{"number":2,"scale":0},
   883  								"max":{"number":16,"scale":0}
   884  							}
   885  						]
   886  					}
   887  				]
   888  			},
   889  			{
   890  				"electricalConnectionId":0,
   891  				"parameterId":3,
   892  				"permittedValueSet":[
   893  					{
   894  						"range":[
   895  							{
   896  								"min":{"number":2,"scale":0},
   897  								"max":{"number":16,"scale":0}
   898  							}
   899  						]
   900  					}
   901  				]
   902  			}
   903  		]
   904  	}`
   905  
   906  	var newData ElectricalConnectionPermittedValueSetListDataType
   907  	err = json.Unmarshal([]byte(newDataJson), &newData)
   908  	if assert.Nil(t, err) == false {
   909  		return
   910  	}
   911  
   912  	deleteFilter := &FilterType{
   913  		CmdControl: &CmdControlType{
   914  			Delete: &ElementTagType{},
   915  		},
   916  		ElectricalConnectionPermittedValueSetListDataSelectors: &ElectricalConnectionPermittedValueSetListDataSelectorsType{
   917  			ElectricalConnectionId: util.Ptr[ElectricalConnectionIdType](0),
   918  			ParameterId:            util.Ptr[ElectricalConnectionParameterIdType](0),
   919  		},
   920  	}
   921  
   922  	// Act
   923  	_, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), deleteFilter)
   924  	assert.True(t, success)
   925  
   926  	data := sut.ElectricalConnectionPermittedValueSetData
   927  	// check the deleted item is added again
   928  	assert.Equal(t, 4, len(data))
   929  	item1 := data[0]
   930  	assert.Equal(t, 0, int(*item1.ElectricalConnectionId))
   931  	assert.Equal(t, 0, int(*item1.ParameterId))
   932  	assert.Equal(t, 1, len(item1.PermittedValueSet))
   933  	// check properties of updated item
   934  	item2 := data[1]
   935  	assert.Equal(t, 0, int(*item2.ElectricalConnectionId))
   936  	assert.Equal(t, 1, int(*item2.ParameterId))
   937  	assert.Equal(t, 1, len(item2.PermittedValueSet))
   938  	valueSet := item2.PermittedValueSet[0]
   939  	assert.Equal(t, 1, len(valueSet.Range))
   940  	rangeSet := valueSet.Range[0]
   941  	assert.Equal(t, 2.0, rangeSet.Min.GetValue())
   942  	assert.Equal(t, 16.0, rangeSet.Max.GetValue())
   943  }
   944  
   945  // verifies that an item in the payload which is not in the existing data will be added
   946  func TestElectricalConnectionPermittedValueSetListDataType_Update_NewItem(t *testing.T) {
   947  	existingDataJson := `{
   948  		"electricalConnectionPermittedValueSetData": [
   949  		  {
   950  			"electricalConnectionId": 1,
   951  			"parameterId": 1,
   952  			"permittedValueSet": [
   953  			  {
   954  				"range": [
   955  				  {
   956  					"min": { "number": 3, "scale": 0 },
   957  					"max": { "number": 6, "scale": 0 }
   958  				  }
   959  				]
   960  			  }
   961  			]
   962  		  }
   963  		]
   964  	}`
   965  
   966  	var sut ElectricalConnectionPermittedValueSetListDataType
   967  	err := json.Unmarshal([]byte(existingDataJson), &sut)
   968  	if assert.Nil(t, err) == false {
   969  		return
   970  	}
   971  
   972  	newDataJson := `{
   973  		"electricalConnectionPermittedValueSetData": [
   974  		  {
   975  			"electricalConnectionId": 1,
   976  			"parameterId": 2,
   977  			"permittedValueSet": [
   978  			  {
   979  				"range": [
   980  				  {
   981  					"min": { "number": 9, "scale": 0 },
   982  					"max": { "number": 19, "scale": 0 }
   983  				  }
   984  				]
   985  			  },
   986  			  {
   987  				"range": [
   988  				  {
   989  					"min": { "number": 30, "scale": 0 },
   990  					"max": { "number": 36, "scale": 0 }
   991  				  }
   992  				]
   993  			  }
   994  			]
   995  		  }
   996  		]
   997  	}`
   998  
   999  	var newData ElectricalConnectionPermittedValueSetListDataType
  1000  	err = json.Unmarshal([]byte(newDataJson), &newData)
  1001  	if assert.Nil(t, err) == false {
  1002  		return
  1003  	}
  1004  
  1005  	// Act
  1006  	_, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil)
  1007  	assert.True(t, success)
  1008  
  1009  	data := sut.ElectricalConnectionPermittedValueSetData
  1010  	// new item should be added
  1011  	assert.Equal(t, 2, len(data))
  1012  	item1 := data[0]
  1013  	assert.Equal(t, 1, int(*item1.ElectricalConnectionId))
  1014  	assert.Equal(t, 1, int(*item1.ParameterId))
  1015  	assert.Equal(t, 1, len(item1.PermittedValueSet))
  1016  	// check properties of added item
  1017  	item2 := data[1]
  1018  	assert.Equal(t, 1, int(*item2.ElectricalConnectionId))
  1019  	assert.Equal(t, 2, int(*item2.ParameterId))
  1020  	assert.Equal(t, 2, len(item2.PermittedValueSet))
  1021  }
  1022  
  1023  // verifies that an item in the payload which has no identifiers will be copied to all existing data
  1024  // (see EEBus_SPINE_TS_ProtocolSpecification.pdf, Table 7: Considered cmdOptions combinations for classifier "notify")
  1025  func TestElectricalConnectionPermittedValueSetListDataType_UpdateWithoutIdenifiers(t *testing.T) {
  1026  	existingDataJson := `{
  1027  		"electricalConnectionPermittedValueSetData": [
  1028  		  {
  1029  			"electricalConnectionId": 1,
  1030  			"parameterId": 1,
  1031  			"permittedValueSet": [
  1032  			  {
  1033  				"range": [
  1034  				  {
  1035  					"min": { "number": 3, "scale": 0 },
  1036  					"max": { "number": 6, "scale": 0 }
  1037  				  }
  1038  				]
  1039  			  }
  1040  			]
  1041  		  },
  1042  		  {
  1043  			"electricalConnectionId": 1,
  1044  			"parameterId": 2,
  1045  			"permittedValueSet": [
  1046  			  {
  1047  				"range": [
  1048  				  {
  1049  					"min": { "number": 6, "scale": 0 },
  1050  					"max": { "number": 12, "scale": 0 }
  1051  				  }
  1052  				]
  1053  			  }
  1054  			]
  1055  		  }		]
  1056  	}`
  1057  
  1058  	var sut ElectricalConnectionPermittedValueSetListDataType
  1059  	err := json.Unmarshal([]byte(existingDataJson), &sut)
  1060  	if assert.Nil(t, err) == false {
  1061  		return
  1062  	}
  1063  
  1064  	// item with no identifiers
  1065  	newDataJson := `{
  1066  		"electricalConnectionPermittedValueSetData": [
  1067  		  {
  1068  			"permittedValueSet": [
  1069  			  {
  1070  				"range": [
  1071  				  {
  1072  					"min": { "number": 30, "scale": 0 },
  1073  					"max": { "number": 36, "scale": 0 }
  1074  				  }
  1075  				]
  1076  			  }
  1077  			]
  1078  		  }
  1079  		]
  1080  	}`
  1081  
  1082  	var newData ElectricalConnectionPermittedValueSetListDataType
  1083  	err = json.Unmarshal([]byte(newDataJson), &newData)
  1084  	if assert.Nil(t, err) == false {
  1085  		return
  1086  	}
  1087  
  1088  	// Act
  1089  	_, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil)
  1090  	assert.True(t, success)
  1091  
  1092  	data := sut.ElectricalConnectionPermittedValueSetData
  1093  	// the new item should not be added
  1094  	assert.Equal(t, 2, len(data))
  1095  	item1 := data[0]
  1096  	assert.Equal(t, 1, int(*item1.ElectricalConnectionId))
  1097  	assert.Equal(t, 1, int(*item1.ParameterId))
  1098  	assert.Equal(t, 1, len(item1.PermittedValueSet))
  1099  	valueSet := item1.PermittedValueSet[0]
  1100  	assert.Equal(t, 1, len(valueSet.Range))
  1101  	// the values of the item in the payload should be copied to the first item
  1102  	assert.Equal(t, 30, int(*valueSet.Range[0].Min.Number))
  1103  	assert.Equal(t, 0, int(*valueSet.Range[0].Min.Scale))
  1104  	assert.Equal(t, 36, int(*valueSet.Range[0].Max.Number))
  1105  	assert.Equal(t, 0, int(*valueSet.Range[0].Max.Scale))
  1106  
  1107  	item2 := data[1]
  1108  	assert.Equal(t, 1, int(*item2.ElectricalConnectionId))
  1109  	assert.Equal(t, 2, int(*item2.ParameterId))
  1110  	assert.Equal(t, 1, len(item2.PermittedValueSet))
  1111  	valueSet = item2.PermittedValueSet[0]
  1112  	assert.Equal(t, 1, len(valueSet.Range))
  1113  	// the values of the item in the payload should be also copied to the second item
  1114  	assert.Equal(t, 30, int(*valueSet.Range[0].Min.Number))
  1115  	assert.Equal(t, 0, int(*valueSet.Range[0].Min.Scale))
  1116  	assert.Equal(t, 36, int(*valueSet.Range[0].Max.Number))
  1117  	assert.Equal(t, 0, int(*valueSet.Range[0].Max.Scale))
  1118  }
  1119  
  1120  func TestElectricalConnectionDescriptionListDataType_Update(t *testing.T) {
  1121  	sut := ElectricalConnectionDescriptionListDataType{
  1122  		ElectricalConnectionDescriptionData: []ElectricalConnectionDescriptionDataType{
  1123  			{
  1124  				ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(0)),
  1125  				PowerSupplyType:        util.Ptr(ElectricalConnectionVoltageTypeTypeAc),
  1126  			},
  1127  			{
  1128  				ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(1)),
  1129  				PowerSupplyType:        util.Ptr(ElectricalConnectionVoltageTypeTypeAc),
  1130  			},
  1131  		},
  1132  	}
  1133  
  1134  	newData := ElectricalConnectionDescriptionListDataType{
  1135  		ElectricalConnectionDescriptionData: []ElectricalConnectionDescriptionDataType{
  1136  			{
  1137  				ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(1)),
  1138  				PowerSupplyType:        util.Ptr(ElectricalConnectionVoltageTypeTypeDc),
  1139  			},
  1140  		},
  1141  	}
  1142  
  1143  	// Act
  1144  	_, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil)
  1145  	assert.True(t, success)
  1146  
  1147  	data := sut.ElectricalConnectionDescriptionData
  1148  	// check the non changing items
  1149  	assert.Equal(t, 2, len(data))
  1150  	item1 := data[0]
  1151  	assert.Equal(t, 0, int(*item1.ElectricalConnectionId))
  1152  	assert.Equal(t, ElectricalConnectionVoltageTypeTypeAc, *item1.PowerSupplyType)
  1153  	// check properties of updated item
  1154  	item2 := data[1]
  1155  	assert.Equal(t, 1, int(*item2.ElectricalConnectionId))
  1156  	assert.Equal(t, ElectricalConnectionVoltageTypeTypeDc, *item2.PowerSupplyType)
  1157  }
  1158  
  1159  func TestElectricalConnectionCharacteristicListDataType_Update(t *testing.T) {
  1160  	sut := ElectricalConnectionCharacteristicListDataType{
  1161  		ElectricalConnectionCharacteristicData: []ElectricalConnectionCharacteristicDataType{
  1162  			{
  1163  				ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(0)),
  1164  				ParameterId:            util.Ptr(ElectricalConnectionParameterIdType(0)),
  1165  				CharacteristicId:       util.Ptr(ElectricalConnectionCharacteristicIdType(0)),
  1166  				CharacteristicType:     util.Ptr(ElectricalConnectionCharacteristicTypeTypeApparentPowerConsumptionNominalMax),
  1167  			},
  1168  			{
  1169  				ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(1)),
  1170  				ParameterId:            util.Ptr(ElectricalConnectionParameterIdType(0)),
  1171  				CharacteristicId:       util.Ptr(ElectricalConnectionCharacteristicIdType(1)),
  1172  				CharacteristicType:     util.Ptr(ElectricalConnectionCharacteristicTypeTypePowerConsumptionMax),
  1173  			},
  1174  		},
  1175  	}
  1176  
  1177  	newData := ElectricalConnectionCharacteristicListDataType{
  1178  		ElectricalConnectionCharacteristicData: []ElectricalConnectionCharacteristicDataType{
  1179  			{
  1180  				ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(1)),
  1181  				ParameterId:            util.Ptr(ElectricalConnectionParameterIdType(0)),
  1182  				CharacteristicId:       util.Ptr(ElectricalConnectionCharacteristicIdType(1)),
  1183  				CharacteristicType:     util.Ptr(ElectricalConnectionCharacteristicTypeTypeEnergyCapacityNominalMax),
  1184  			},
  1185  		},
  1186  	}
  1187  
  1188  	// Act
  1189  	_, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil)
  1190  	assert.True(t, success)
  1191  
  1192  	data := sut.ElectricalConnectionCharacteristicData
  1193  	// check the non changing items
  1194  	assert.Equal(t, 2, len(data))
  1195  	item1 := data[0]
  1196  	assert.Equal(t, 0, int(*item1.ElectricalConnectionId))
  1197  	assert.Equal(t, ElectricalConnectionCharacteristicTypeTypeApparentPowerConsumptionNominalMax, *item1.CharacteristicType)
  1198  	// check properties of updated item
  1199  	item2 := data[1]
  1200  	assert.Equal(t, 1, int(*item2.ElectricalConnectionId))
  1201  	assert.Equal(t, ElectricalConnectionCharacteristicTypeTypeEnergyCapacityNominalMax, *item2.CharacteristicType)
  1202  }
  1203  
  1204  func TestElectricalConnectionParameterDescriptionListDataType_Update(t *testing.T) {
  1205  	sut := ElectricalConnectionParameterDescriptionListDataType{
  1206  		ElectricalConnectionParameterDescriptionData: []ElectricalConnectionParameterDescriptionDataType{
  1207  			{
  1208  				ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(0)),
  1209  				ParameterId:            util.Ptr(ElectricalConnectionParameterIdType(0)),
  1210  				VoltageType:            util.Ptr(ElectricalConnectionVoltageTypeTypeAc),
  1211  			},
  1212  			{
  1213  				ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(1)),
  1214  				ParameterId:            util.Ptr(ElectricalConnectionParameterIdType(0)),
  1215  				MeasurementId:          util.Ptr(MeasurementIdType(0)),
  1216  				VoltageType:            util.Ptr(ElectricalConnectionVoltageTypeTypeAc),
  1217  			},
  1218  		},
  1219  	}
  1220  
  1221  	newData := ElectricalConnectionParameterDescriptionListDataType{
  1222  		ElectricalConnectionParameterDescriptionData: []ElectricalConnectionParameterDescriptionDataType{
  1223  			{
  1224  				ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(1)),
  1225  				ParameterId:            util.Ptr(ElectricalConnectionParameterIdType(0)),
  1226  				VoltageType:            util.Ptr(ElectricalConnectionVoltageTypeTypeDc),
  1227  			},
  1228  		},
  1229  	}
  1230  
  1231  	// Act
  1232  	_, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil)
  1233  	assert.True(t, success)
  1234  
  1235  	data := sut.ElectricalConnectionParameterDescriptionData
  1236  	// check the non changing items
  1237  	assert.Equal(t, 2, len(data))
  1238  	item1 := data[0]
  1239  	assert.Equal(t, 0, int(*item1.ElectricalConnectionId))
  1240  	assert.Equal(t, ElectricalConnectionVoltageTypeTypeAc, *item1.VoltageType)
  1241  	// check properties of updated item
  1242  	item2 := data[1]
  1243  	assert.Equal(t, 1, int(*item2.ElectricalConnectionId))
  1244  	assert.Equal(t, ElectricalConnectionVoltageTypeTypeDc, *item2.VoltageType)
  1245  }