gerrit.onap Code Review - sdc.git/blob

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