catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/datamodel/TopologyTemplateTest.java

   1 package org.openecomp.sdc.be.model.jsontitan.datamodel;
   2
   3 import java.util.Map;
   4
   5 import org.junit.Test;
   6 import org.openecomp.sdc.be.datatypes.elements.*;
   7 import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition;
   8 import org.openecomp.sdc.be.model.DataTypeDefinition;
   9
  10
  11 public class TopologyTemplateTest {
  12
  13         private TopologyTemplate createTestSubject() {
  14                 return new TopologyTemplate();
  15         }
  16
  17
  18         @Test
  19         public void testGetInputs() throws Exception {
  20                 TopologyTemplate testSubject;
  21                 Map<String, PropertyDataDefinition> result;
  22
  23                 // default test
  24                 testSubject = createTestSubject();
  25                 result = testSubject.getInputs();
  26         }
  27
  28
  29         @Test
  30         public void testSetInputs() throws Exception {
  31                 TopologyTemplate testSubject;
  32                 Map<String, PropertyDataDefinition> inputs = null;
  33
  34                 // default test
  35                 testSubject = createTestSubject();
  36                 testSubject.setInputs(inputs);
  37         }
  38
  39
  40         @Test
  41         public void testGetInstInputs() throws Exception {
  42                 TopologyTemplate testSubject;
  43                 Map<String, MapPropertiesDataDefinition> result;
  44
  45                 // default test
  46                 testSubject = createTestSubject();
  47                 result = testSubject.getInstInputs();
  48         }
  49
  50
  51         @Test
  52         public void testSetInstInputs() throws Exception {
  53                 TopologyTemplate testSubject;
  54                 Map<String, MapPropertiesDataDefinition> instInputs = null;
  55
  56                 // default test
  57                 testSubject = createTestSubject();
  58                 testSubject.setInstInputs(instInputs);
  59         }
  60
  61
  62         @Test
  63         public void testGetHeatParameters() throws Exception {
  64                 TopologyTemplate testSubject;
  65                 Map<String, ? extends ToscaDataDefinition> result;
  66
  67                 // default test
  68                 testSubject = createTestSubject();
  69                 result = testSubject.getHeatParameters();
  70         }
  71
  72
  73         @Test
  74         public void testSetHeatParameters() throws Exception {
  75                 TopologyTemplate testSubject;
  76                 Map<String, ? extends ToscaDataDefinition> heatParameters = null;
  77
  78                 // default test
  79                 testSubject = createTestSubject();
  80                 testSubject.setHeatParameters(heatParameters);
  81         }
  82
  83
  84         @Test
  85         public void testGetInstAttributes() throws Exception {
  86                 TopologyTemplate testSubject;
  87                 Map<String, MapPropertiesDataDefinition> result;
  88
  89                 // default test
  90                 testSubject = createTestSubject();
  91                 result = testSubject.getInstAttributes();
  92         }
  93
  94
  95         @Test
  96         public void testSetInstAttributes() throws Exception {
  97                 TopologyTemplate testSubject;
  98                 Map<String, MapPropertiesDataDefinition> instAttributes = null;
  99
 100                 // default test
 101                 testSubject = createTestSubject();
 102                 testSubject.setInstAttributes(instAttributes);
 103         }
 104
 105
 106         @Test
 107         public void testGetInstProperties() throws Exception {
 108                 TopologyTemplate testSubject;
 109                 Map<String, MapPropertiesDataDefinition> result;
 110
 111                 // default test
 112                 testSubject = createTestSubject();
 113                 result = testSubject.getInstProperties();
 114         }
 115
 116
 117         @Test
 118         public void testSetInstProperties() throws Exception {
 119                 TopologyTemplate testSubject;
 120                 Map<String, MapPropertiesDataDefinition> instProperties = null;
 121
 122                 // default test
 123                 testSubject = createTestSubject();
 124                 testSubject.setInstProperties(instProperties);
 125         }
 126
 127
 128         @Test
 129         public void testGetGroups() throws Exception {
 130                 TopologyTemplate testSubject;
 131                 Map<String, GroupDataDefinition> result;
 132
 133                 // default test
 134                 testSubject = createTestSubject();
 135                 result = testSubject.getGroups();
 136         }
 137
 138
 139         @Test
 140         public void testSetGroups() throws Exception {
 141                 TopologyTemplate testSubject;
 142                 Map<String, GroupDataDefinition> groups = null;
 143
 144                 // default test
 145                 testSubject = createTestSubject();
 146                 testSubject.setGroups(groups);
 147         }
 148
 149
 150         @Test
 151         public void testGetInstGroups() throws Exception {
 152                 TopologyTemplate testSubject;
 153                 Map<String, MapGroupsDataDefinition> result;
 154
 155                 // default test
 156                 testSubject = createTestSubject();
 157                 result = testSubject.getInstGroups();
 158         }
 159
 160
 161         @Test
 162         public void testSetInstGroups() throws Exception {
 163                 TopologyTemplate testSubject;
 164                 Map<String, MapGroupsDataDefinition> instGroups = null;
 165
 166                 // default test
 167                 testSubject = createTestSubject();
 168                 testSubject.setInstGroups(instGroups);
 169         }
 170
 171
 172         @Test
 173         public void testGetServiceApiArtifacts() throws Exception {
 174                 TopologyTemplate testSubject;
 175                 Map<String, ArtifactDataDefinition> result;
 176
 177                 // default test
 178                 testSubject = createTestSubject();
 179                 result = testSubject.getServiceApiArtifacts();
 180         }
 181
 182
 183         @Test
 184         public void testSetServiceApiArtifacts() throws Exception {
 185                 TopologyTemplate testSubject;
 186                 Map<String, ArtifactDataDefinition> serviceApiArtifacts = null;
 187
 188                 // default test
 189                 testSubject = createTestSubject();
 190                 testSubject.setServiceApiArtifacts(serviceApiArtifacts);
 191         }
 192
 193
 194         @Test
 195         public void testGetCompositions() throws Exception {
 196                 TopologyTemplate testSubject;
 197                 Map<String, CompositionDataDefinition> result;
 198
 199                 // default test
 200                 testSubject = createTestSubject();
 201                 result = testSubject.getCompositions();
 202         }
 203
 204
 205         @Test
 206         public void testSetCompositions() throws Exception {
 207                 TopologyTemplate testSubject;
 208                 Map<String, CompositionDataDefinition> compositions = null;
 209
 210                 // default test
 211                 testSubject = createTestSubject();
 212                 testSubject.setCompositions(compositions);
 213         }
 214
 215
 216         @Test
 217         public void testGetCalculatedCapabilities() throws Exception {
 218                 TopologyTemplate testSubject;
 219                 Map<String, MapListCapabilityDataDefinition> result;
 220
 221                 // default test
 222                 testSubject = createTestSubject();
 223                 result = testSubject.getCalculatedCapabilities();
 224         }
 225
 226
 227         @Test
 228         public void testSetCalculatedCapabilities() throws Exception {
 229                 TopologyTemplate testSubject;
 230                 Map<String, MapListCapabilityDataDefinition> calculatedCapabilities = null;
 231
 232                 // default test
 233                 testSubject = createTestSubject();
 234                 testSubject.setCalculatedCapabilities(calculatedCapabilities);
 235         }
 236
 237
 238         @Test
 239         public void testGetCalculatedRequirements() throws Exception {
 240                 TopologyTemplate testSubject;
 241                 Map<String, MapListRequirementDataDefinition> result;
 242
 243                 // default test
 244                 testSubject = createTestSubject();
 245                 result = testSubject.getCalculatedRequirements();
 246         }
 247
 248
 249         @Test
 250         public void testSetCalculatedRequirements() throws Exception {
 251                 TopologyTemplate testSubject;
 252                 Map<String, MapListRequirementDataDefinition> calculatedRequirements = null;
 253
 254                 // default test
 255                 testSubject = createTestSubject();
 256                 testSubject.setCalculatedRequirements(calculatedRequirements);
 257         }
 258
 259
 260         @Test
 261         public void testGetFullfilledCapabilities() throws Exception {
 262                 TopologyTemplate testSubject;
 263                 Map<String, MapListCapabilityDataDefinition> result;
 264
 265                 // default test
 266                 testSubject = createTestSubject();
 267                 result = testSubject.getFullfilledCapabilities();
 268         }
 269
 270
 271         @Test
 272         public void testSetFullfilledCapabilities() throws Exception {
 273                 TopologyTemplate testSubject;
 274                 Map<String, MapListCapabilityDataDefinition> fullfilledCapabilities = null;
 275
 276                 // default test
 277                 testSubject = createTestSubject();
 278                 testSubject.setFullfilledCapabilities(fullfilledCapabilities);
 279         }
 280
 281
 282         @Test
 283         public void testGetFullfilledRequirements() throws Exception {
 284                 TopologyTemplate testSubject;
 285                 Map<String, MapListRequirementDataDefinition> result;
 286
 287                 // default test
 288                 testSubject = createTestSubject();
 289                 result = testSubject.getFullfilledRequirements();
 290         }
 291
 292
 293         @Test
 294         public void testSetFullfilledRequirements() throws Exception {
 295                 TopologyTemplate testSubject;
 296                 Map<String, MapListRequirementDataDefinition> fullfilledRequirements = null;
 297
 298                 // default test
 299                 testSubject = createTestSubject();
 300                 testSubject.setFullfilledRequirements(fullfilledRequirements);
 301         }
 302
 303
 304         @Test
 305         public void testGetInstDeploymentArtifacts() throws Exception {
 306                 TopologyTemplate testSubject;
 307                 Map<String, MapArtifactDataDefinition> result;
 308
 309                 // default test
 310                 testSubject = createTestSubject();
 311                 result = testSubject.getInstDeploymentArtifacts();
 312         }
 313
 314
 315         @Test
 316         public void testSetInstDeploymentArtifacts() throws Exception {
 317                 TopologyTemplate testSubject;
 318                 Map<String, MapArtifactDataDefinition> instDeploymentArtifacts = null;
 319
 320                 // default test
 321                 testSubject = createTestSubject();
 322                 testSubject.setInstDeploymentArtifacts(instDeploymentArtifacts);
 323         }
 324
 325
 326         @Test
 327         public void testGetCalculatedCapabilitiesProperties() throws Exception {
 328                 TopologyTemplate testSubject;
 329                 Map<String, MapCapabilityProperty> result;
 330
 331                 // default test
 332                 testSubject = createTestSubject();
 333                 result = testSubject.getCalculatedCapabilitiesProperties();
 334         }
 335
 336
 337         @Test
 338         public void testSetCalculatedCapabilitiesProperties() throws Exception {
 339                 TopologyTemplate testSubject;
 340                 Map<String, MapCapabilityProperty> calculatedCapabilitiesProperties = null;
 341
 342                 // default test
 343                 testSubject = createTestSubject();
 344                 testSubject.setCalculatedCapabilitiesProperties(calculatedCapabilitiesProperties);
 345         }
 346
 347
 348         @Test
 349         public void testGetInstanceArtifacts() throws Exception {
 350                 TopologyTemplate testSubject;
 351                 Map<String, MapArtifactDataDefinition> result;
 352
 353                 // default test
 354                 testSubject = createTestSubject();
 355                 result = testSubject.getInstanceArtifacts();
 356         }
 357
 358
 359         @Test
 360         public void testSetInstanceArtifacts() throws Exception {
 361                 TopologyTemplate testSubject;
 362                 Map<String, MapArtifactDataDefinition> instanceArtifacts = null;
 363
 364                 // default test
 365                 testSubject = createTestSubject();
 366                 testSubject.setInstanceArtifacts(instanceArtifacts);
 367         }
 368
 369
 370         @Test
 371         public void testGetDataTypes() throws Exception {
 372                 TopologyTemplate testSubject;
 373                 Map<String, DataTypeDataDefinition> result;
 374
 375                 // default test
 376                 testSubject = createTestSubject();
 377                 result = testSubject.getDataTypes();
 378         }
 379
 380
 381         @Test
 382         public void testSetDataTypes() throws Exception {
 383                 TopologyTemplate testSubject;
 384                 Map<String, DataTypeDataDefinition> dataTypes = null;
 385
 386                 // default test
 387                 testSubject = createTestSubject();
 388                 testSubject.setDataTypes(dataTypes);
 389         }
 390
 391
 392         @Test
 393         public void testGetComponentInstances() throws Exception {
 394                 TopologyTemplate testSubject;
 395                 Map<String, ComponentInstanceDataDefinition> result;
 396
 397                 // default test
 398                 testSubject = createTestSubject();
 399                 result = testSubject.getComponentInstances();
 400         }
 401
 402
 403         @Test
 404         public void testSetComponentInstances() throws Exception {
 405                 TopologyTemplate testSubject;
 406                 Map<String, ComponentInstanceDataDefinition> instances = null;
 407
 408                 // default test
 409                 testSubject = createTestSubject();
 410                 testSubject.setComponentInstances(instances);
 411         }
 412
 413
 414         @Test
 415         public void testGetRelations() throws Exception {
 416                 TopologyTemplate testSubject;
 417                 Map<String, RelationshipInstDataDefinition> result;
 418
 419                 // default test
 420                 testSubject = createTestSubject();
 421                 result = testSubject.getRelations();
 422         }
 423 }