diff options
11 files changed, 4887 insertions, 0 deletions
diff --git a/UniversalVesAdapter/src/test/java/org/onap/dcaegen2/ves/domain/AdditionalMeasurementTest.java b/UniversalVesAdapter/src/test/java/org/onap/dcaegen2/ves/domain/AdditionalMeasurementTest.java new file mode 100644 index 0000000..1b9149b --- /dev/null +++ b/UniversalVesAdapter/src/test/java/org/onap/dcaegen2/ves/domain/AdditionalMeasurementTest.java @@ -0,0 +1,124 @@ +/* +* ============LICENSE_START======================================================= +* ONAP : DCAE +* ================================================================================ +* Copyright 2018 TechMahindra +*================================================================================= +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +* ============LICENSE_END========================================================= +*/ +package org.onap.dcaegen2.ves.domain; + +import java.util.List; +import java.util.Map; +import org.onap.dcaegen2.ves.domain.AdditionalMeasurement; +import org.junit.Test; + +public class AdditionalMeasurementTest { + + private AdditionalMeasurement createTestSubject() { + return new AdditionalMeasurement(); + } + + @Test + public void testGetName() throws Exception { + AdditionalMeasurement testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getName(); + } + + @Test + public void testSetName() throws Exception { + AdditionalMeasurement testSubject; + String name = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setName(name); + } + + @Test + public void testGetArrayOfFields() throws Exception { + AdditionalMeasurement testSubject; + List<ArrayOfField> result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getArrayOfFields(); + } + + @Test + public void testSetArrayOfFields() throws Exception { + AdditionalMeasurement testSubject; + List<ArrayOfField> arrayOfFields = null; + + // default test + testSubject = createTestSubject(); + testSubject.setArrayOfFields(arrayOfFields); + } + + @Test + public void testGetAdditionalProperties() throws Exception { + AdditionalMeasurement testSubject; + Map<String, Object> result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getAdditionalProperties(); + } + + @Test + public void testSetAdditionalProperty() throws Exception { + AdditionalMeasurement testSubject; + String name = ""; + Object value = null; + + // default test + testSubject = createTestSubject(); + testSubject.setAdditionalProperty(name, value); + } + + @Test + public void testToString() throws Exception { + AdditionalMeasurement testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.toString(); + } + + @Test + public void testHashCode() throws Exception { + AdditionalMeasurement testSubject; + int result; + + // default test + testSubject = createTestSubject(); + result = testSubject.hashCode(); + } + + @Test + public void testEquals() throws Exception { + AdditionalMeasurement testSubject; + Object other = null; + boolean result; + + // default test + testSubject = createTestSubject(); + result = testSubject.equals(other); + } +}
\ No newline at end of file diff --git a/UniversalVesAdapter/src/test/java/org/onap/dcaegen2/ves/domain/AdditionalObjectTest.java b/UniversalVesAdapter/src/test/java/org/onap/dcaegen2/ves/domain/AdditionalObjectTest.java new file mode 100644 index 0000000..fc28bd5 --- /dev/null +++ b/UniversalVesAdapter/src/test/java/org/onap/dcaegen2/ves/domain/AdditionalObjectTest.java @@ -0,0 +1,204 @@ +/* +* ============LICENSE_START======================================================= +* ONAP : DCAE +* ================================================================================ +* Copyright 2018 TechMahindra +*================================================================================= +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +* ============LICENSE_END========================================================= +*/ +package org.onap.dcaegen2.ves.domain; + +import java.util.List; +import java.util.Map; +import org.onap.dcaegen2.ves.domain.AdditionalInformation; +import org.junit.Test; + +public class AdditionalObjectTest { + + private AdditionalObject createTestSubject() { + return new AdditionalObject(); + } + + @Test + public void testGetObjectInstances() throws Exception { + AdditionalObject testSubject; + List<ObjectInstance> result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getObjectInstances(); + } + + @Test + public void testSetObjectInstances() throws Exception { + AdditionalObject testSubject; + List<ObjectInstance> objectInstances = null; + + // default test + testSubject = createTestSubject(); + testSubject.setObjectInstances(objectInstances); + } + + @Test + public void testGetObjectName() throws Exception { + AdditionalObject testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getObjectName(); + } + + @Test + public void testSetObjectName() throws Exception { + AdditionalObject testSubject; + String objectName = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setObjectName(objectName); + } + + @Test + public void testGetObjectSchema() throws Exception { + AdditionalObject testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getObjectSchema(); + } + + @Test + public void testSetObjectSchema() throws Exception { + AdditionalObject testSubject; + String objectSchema = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setObjectSchema(objectSchema); + } + + @Test + public void testGetObjectSchemaUrl() throws Exception { + AdditionalObject testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getObjectSchemaUrl(); + } + + @Test + public void testSetObjectSchemaUrl() throws Exception { + AdditionalObject testSubject; + String objectSchemaUrl = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setObjectSchemaUrl(objectSchemaUrl); + } + + @Test + public void testGetNfSubscribedObjectName() throws Exception { + AdditionalObject testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getNfSubscribedObjectName(); + } + + @Test + public void testSetNfSubscribedObjectName() throws Exception { + AdditionalObject testSubject; + String nfSubscribedObjectName = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setNfSubscribedObjectName(nfSubscribedObjectName); + } + + @Test + public void testGetNfSubscriptionId() throws Exception { + AdditionalObject testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getNfSubscriptionId(); + } + + @Test + public void testSetNfSubscriptionId() throws Exception { + AdditionalObject testSubject; + String nfSubscriptionId = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setNfSubscriptionId(nfSubscriptionId); + } + + @Test + public void testGetAdditionalProperties() throws Exception { + AdditionalObject testSubject; + Map<String, Object> result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getAdditionalProperties(); + } + + @Test + public void testSetAdditionalProperty() throws Exception { + AdditionalObject testSubject; + String name = ""; + Object value = null; + + // default test + testSubject = createTestSubject(); + testSubject.setAdditionalProperty(name, value); + } + + @Test + public void testToString() throws Exception { + AdditionalObject testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.toString(); + } + + @Test + public void testHashCode() throws Exception { + AdditionalObject testSubject; + int result; + + // default test + testSubject = createTestSubject(); + result = testSubject.hashCode(); + } + + @Test + public void testEquals() throws Exception { + AdditionalObject testSubject; + Object other = null; + boolean result; + + // default test + testSubject = createTestSubject(); + result = testSubject.equals(other); + } +}
\ No newline at end of file diff --git a/UniversalVesAdapter/src/test/java/org/onap/dcaegen2/ves/domain/DiskUsageArrayTest.java b/UniversalVesAdapter/src/test/java/org/onap/dcaegen2/ves/domain/DiskUsageArrayTest.java new file mode 100644 index 0000000..eb34e1d --- /dev/null +++ b/UniversalVesAdapter/src/test/java/org/onap/dcaegen2/ves/domain/DiskUsageArrayTest.java @@ -0,0 +1,903 @@ +/* +* ============LICENSE_START======================================================= +* ONAP : DCAE +* ================================================================================ +* Copyright 2018 TechMahindra +*================================================================================= +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +* ============LICENSE_END========================================================= +*/ +package org.onap.dcaegen2.ves.domain; + +import java.util.Map; + +import org.junit.Test; + +public class DiskUsageArrayTest { + + private DiskUsageArray createTestSubject() { + return new DiskUsageArray(); + } + + @Test + public void testGetDiskIdentifier() throws Exception { + DiskUsageArray testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskIdentifier(); + } + + @Test + public void testSetDiskIdentifier() throws Exception { + DiskUsageArray testSubject; + String diskIdentifier = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskIdentifier(diskIdentifier); + } + + @Test + public void testGetDiskIoTimeAvg() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskIoTimeAvg(); + } + + @Test + public void testSetDiskIoTimeAvg() throws Exception { + DiskUsageArray testSubject; + Double diskIoTimeAvg = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskIoTimeAvg(diskIoTimeAvg); + } + + @Test + public void testGetDiskIoTimeLast() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskIoTimeLast(); + } + + @Test + public void testSetDiskIoTimeLast() throws Exception { + DiskUsageArray testSubject; + Double diskIoTimeLast = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskIoTimeLast(diskIoTimeLast); + } + + @Test + public void testGetDiskIoTimeMax() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskIoTimeMax(); + } + + @Test + public void testSetDiskIoTimeMax() throws Exception { + DiskUsageArray testSubject; + Double diskIoTimeMax = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskIoTimeMax(diskIoTimeMax); + } + + @Test + public void testGetDiskIoTimeMin() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskIoTimeMin(); + } + + @Test + public void testSetDiskIoTimeMin() throws Exception { + DiskUsageArray testSubject; + Double diskIoTimeMin = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskIoTimeMin(diskIoTimeMin); + } + + @Test + public void testGetDiskMergedReadAvg() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskMergedReadAvg(); + } + + @Test + public void testSetDiskMergedReadAvg() throws Exception { + DiskUsageArray testSubject; + Double diskMergedReadAvg = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskMergedReadAvg(diskMergedReadAvg); + } + + @Test + public void testGetDiskMergedReadLast() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskMergedReadLast(); + } + + @Test + public void testSetDiskMergedReadLast() throws Exception { + DiskUsageArray testSubject; + Double diskMergedReadLast = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskMergedReadLast(diskMergedReadLast); + } + + @Test + public void testGetDiskMergedReadMax() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskMergedReadMax(); + } + + @Test + public void testSetDiskMergedReadMax() throws Exception { + DiskUsageArray testSubject; + Double diskMergedReadMax = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskMergedReadMax(diskMergedReadMax); + } + + @Test + public void testGetDiskMergedReadMin() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskMergedReadMin(); + } + + @Test + public void testSetDiskMergedReadMin() throws Exception { + DiskUsageArray testSubject; + Double diskMergedReadMin = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskMergedReadMin(diskMergedReadMin); + } + + @Test + public void testGetDiskMergedWriteAvg() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskMergedWriteAvg(); + } + + @Test + public void testSetDiskMergedWriteAvg() throws Exception { + DiskUsageArray testSubject; + Double diskMergedWriteAvg = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskMergedWriteAvg(diskMergedWriteAvg); + } + + @Test + public void testGetDiskMergedWriteLast() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskMergedWriteLast(); + } + + @Test + public void testSetDiskMergedWriteLast() throws Exception { + DiskUsageArray testSubject; + Double diskMergedWriteLast = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskMergedWriteLast(diskMergedWriteLast); + } + + @Test + public void testGetDiskMergedWriteMax() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskMergedWriteMax(); + } + + @Test + public void testSetDiskMergedWriteMax() throws Exception { + DiskUsageArray testSubject; + Double diskMergedWriteMax = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskMergedWriteMax(diskMergedWriteMax); + } + + @Test + public void testGetDiskMergedWriteMin() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskMergedWriteMin(); + } + + @Test + public void testSetDiskMergedWriteMin() throws Exception { + DiskUsageArray testSubject; + Double diskMergedWriteMin = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskMergedWriteMin(diskMergedWriteMin); + } + + @Test + public void testGetDiskOctetsReadAvg() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskOctetsReadAvg(); + } + + @Test + public void testSetDiskOctetsReadAvg() throws Exception { + DiskUsageArray testSubject; + Double diskOctetsReadAvg = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskOctetsReadAvg(diskOctetsReadAvg); + } + + @Test + public void testGetDiskOctetsReadLast() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskOctetsReadLast(); + } + + @Test + public void testSetDiskOctetsReadLast() throws Exception { + DiskUsageArray testSubject; + Double diskOctetsReadLast = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskOctetsReadLast(diskOctetsReadLast); + } + + @Test + public void testGetDiskOctetsReadMax() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskOctetsReadMax(); + } + + @Test + public void testSetDiskOctetsReadMax() throws Exception { + DiskUsageArray testSubject; + Double diskOctetsReadMax = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskOctetsReadMax(diskOctetsReadMax); + } + + @Test + public void testGetDiskOctetsReadMin() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskOctetsReadMin(); + } + + @Test + public void testSetDiskOctetsReadMin() throws Exception { + DiskUsageArray testSubject; + Double diskOctetsReadMin = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskOctetsReadMin(diskOctetsReadMin); + } + + @Test + public void testGetDiskOctetsWriteAvg() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskOctetsWriteAvg(); + } + + @Test + public void testSetDiskOctetsWriteAvg() throws Exception { + DiskUsageArray testSubject; + Double diskOctetsWriteAvg = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskOctetsWriteAvg(diskOctetsWriteAvg); + } + + @Test + public void testGetDiskOctetsWriteLast() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskOctetsWriteLast(); + } + + @Test + public void testSetDiskOctetsWriteLast() throws Exception { + DiskUsageArray testSubject; + Double diskOctetsWriteLast = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskOctetsWriteLast(diskOctetsWriteLast); + } + + @Test + public void testGetDiskOctetsWriteMax() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskOctetsWriteMax(); + } + + @Test + public void testSetDiskOctetsWriteMax() throws Exception { + DiskUsageArray testSubject; + Double diskOctetsWriteMax = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskOctetsWriteMax(diskOctetsWriteMax); + } + + @Test + public void testGetDiskOctetsWriteMin() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskOctetsWriteMin(); + } + + @Test + public void testSetDiskOctetsWriteMin() throws Exception { + DiskUsageArray testSubject; + Double diskOctetsWriteMin = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskOctetsWriteMin(diskOctetsWriteMin); + } + + @Test + public void testGetDiskOpsReadAvg() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskOpsReadAvg(); + } + + @Test + public void testSetDiskOpsReadAvg() throws Exception { + DiskUsageArray testSubject; + Double diskOpsReadAvg = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskOpsReadAvg(diskOpsReadAvg); + } + + @Test + public void testGetDiskOpsReadLast() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskOpsReadLast(); + } + + @Test + public void testSetDiskOpsReadLast() throws Exception { + DiskUsageArray testSubject; + Double diskOpsReadLast = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskOpsReadLast(diskOpsReadLast); + } + + @Test + public void testGetDiskOpsReadMax() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskOpsReadMax(); + } + + @Test + public void testSetDiskOpsReadMax() throws Exception { + DiskUsageArray testSubject; + Double diskOpsReadMax = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskOpsReadMax(diskOpsReadMax); + } + + @Test + public void testGetDiskOpsReadMin() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskOpsReadMin(); + } + + @Test + public void testSetDiskOpsReadMin() throws Exception { + DiskUsageArray testSubject; + Double diskOpsReadMin = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskOpsReadMin(diskOpsReadMin); + } + + @Test + public void testGetDiskOpsWriteAvg() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskOpsWriteAvg(); + } + + @Test + public void testSetDiskOpsWriteAvg() throws Exception { + DiskUsageArray testSubject; + Double diskOpsWriteAvg = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskOpsWriteAvg(diskOpsWriteAvg); + } + + @Test + public void testGetDiskOpsWriteLast() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskOpsWriteLast(); + } + + @Test + public void testSetDiskOpsWriteLast() throws Exception { + DiskUsageArray testSubject; + Double diskOpsWriteLast = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskOpsWriteLast(diskOpsWriteLast); + } + + @Test + public void testGetDiskOpsWriteMax() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskOpsWriteMax(); + } + + @Test + public void testSetDiskOpsWriteMax() throws Exception { + DiskUsageArray testSubject; + Double diskOpsWriteMax = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskOpsWriteMax(diskOpsWriteMax); + } + + @Test + public void testGetDiskOpsWriteMin() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskOpsWriteMin(); + } + + @Test + public void testSetDiskOpsWriteMin() throws Exception { + DiskUsageArray testSubject; + Double diskOpsWriteMin = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskOpsWriteMin(diskOpsWriteMin); + } + + @Test + public void testGetDiskPendingOperationsAvg() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskPendingOperationsAvg(); + } + + @Test + public void testSetDiskPendingOperationsAvg() throws Exception { + DiskUsageArray testSubject; + Double diskPendingOperationsAvg = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskPendingOperationsAvg(diskPendingOperationsAvg); + } + + @Test + public void testGetDiskPendingOperationsLast() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskPendingOperationsLast(); + } + + @Test + public void testSetDiskPendingOperationsLast() throws Exception { + DiskUsageArray testSubject; + Double diskPendingOperationsLast = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskPendingOperationsLast(diskPendingOperationsLast); + } + + @Test + public void testGetDiskPendingOperationsMax() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskPendingOperationsMax(); + } + + @Test + public void testSetDiskPendingOperationsMax() throws Exception { + DiskUsageArray testSubject; + Double diskPendingOperationsMax = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskPendingOperationsMax(diskPendingOperationsMax); + } + + @Test + public void testGetDiskPendingOperationsMin() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskPendingOperationsMin(); + } + + @Test + public void testSetDiskPendingOperationsMin() throws Exception { + DiskUsageArray testSubject; + Double diskPendingOperationsMin = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskPendingOperationsMin(diskPendingOperationsMin); + } + + @Test + public void testGetDiskTimeReadAvg() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskTimeReadAvg(); + } + + @Test + public void testSetDiskTimeReadAvg() throws Exception { + DiskUsageArray testSubject; + Double diskTimeReadAvg = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskTimeReadAvg(diskTimeReadAvg); + } + + @Test + public void testGetDiskTimeReadLast() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskTimeReadLast(); + } + + @Test + public void testSetDiskTimeReadLast() throws Exception { + DiskUsageArray testSubject; + Double diskTimeReadLast = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskTimeReadLast(diskTimeReadLast); + } + + @Test + public void testGetDiskTimeReadMax() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskTimeReadMax(); + } + + @Test + public void testSetDiskTimeReadMax() throws Exception { + DiskUsageArray testSubject; + Double diskTimeReadMax = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskTimeReadMax(diskTimeReadMax); + } + + @Test + public void testGetDiskTimeReadMin() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskTimeReadMin(); + } + + @Test + public void testSetDiskTimeReadMin() throws Exception { + DiskUsageArray testSubject; + Double diskTimeReadMin = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskTimeReadMin(diskTimeReadMin); + } + + @Test + public void testGetDiskTimeWriteAvg() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskTimeWriteAvg(); + } + + @Test + public void testSetDiskTimeWriteAvg() throws Exception { + DiskUsageArray testSubject; + Double diskTimeWriteAvg = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskTimeWriteAvg(diskTimeWriteAvg); + } + + @Test + public void testGetDiskTimeWriteLast() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskTimeWriteLast(); + } + + @Test + public void testSetDiskTimeWriteLast() throws Exception { + DiskUsageArray testSubject; + Double diskTimeWriteLast = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskTimeWriteLast(diskTimeWriteLast); + } + + @Test + public void testGetDiskTimeWriteMax() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskTimeWriteMax(); + } + + @Test + public void testSetDiskTimeWriteMax() throws Exception { + DiskUsageArray testSubject; + Double diskTimeWriteMax = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskTimeWriteMax(diskTimeWriteMax); + } + + @Test + public void testGetDiskTimeWriteMin() throws Exception { + DiskUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskTimeWriteMin(); + } + + @Test + public void testSetDiskTimeWriteMin() throws Exception { + DiskUsageArray testSubject; + Double diskTimeWriteMin = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskTimeWriteMin(diskTimeWriteMin); + } + + @Test + public void testGetAdditionalProperties() throws Exception { + DiskUsageArray testSubject; + Map<String, Object> result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getAdditionalProperties(); + } + + @Test + public void testSetAdditionalProperty() throws Exception { + DiskUsageArray testSubject; + String name = ""; + Object value = null; + + // default test + testSubject = createTestSubject(); + testSubject.setAdditionalProperty(name, value); + } + + @Test + public void testToString() throws Exception { + DiskUsageArray testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.toString(); + } + + @Test + public void testHashCode() throws Exception { + DiskUsageArray testSubject; + int result; + + // default test + testSubject = createTestSubject(); + result = testSubject.hashCode(); + } + + @Test + public void testEquals() throws Exception { + DiskUsageArray testSubject; + Object other = null; + boolean result; + + // default test + testSubject = createTestSubject(); + result = testSubject.equals(other); + } +}
\ No newline at end of file diff --git a/UniversalVesAdapter/src/test/java/org/onap/dcaegen2/ves/domain/GtpPerFlowMetricsTest.java b/UniversalVesAdapter/src/test/java/org/onap/dcaegen2/ves/domain/GtpPerFlowMetricsTest.java new file mode 100644 index 0000000..d84f191 --- /dev/null +++ b/UniversalVesAdapter/src/test/java/org/onap/dcaegen2/ves/domain/GtpPerFlowMetricsTest.java @@ -0,0 +1,1084 @@ +/* +* ============LICENSE_START======================================================= +* ONAP : DCAE +* ================================================================================ +* Copyright 2018 TechMahindra +*================================================================================= +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +* ============LICENSE_END========================================================= +*/ +package org.onap.dcaegen2.ves.domain; + +import java.util.List; +import java.util.Map; +import org.onap.dcaegen2.ves.domain.GtpPerFlowMetrics; +import org.junit.Test; + +public class GtpPerFlowMetricsTest { + + private GtpPerFlowMetrics createTestSubject() { + return new GtpPerFlowMetrics(); + } + + @Test + public void testGetAvgBitErrorRate() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getAvgBitErrorRate(); + } + + @Test + public void testSetAvgBitErrorRate() throws Exception { + GtpPerFlowMetrics testSubject; + Double avgBitErrorRate = null; + + // default test + testSubject = createTestSubject(); + testSubject.setAvgBitErrorRate(avgBitErrorRate); + } + + @Test + public void testGetAvgPacketDelayVariation() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getAvgPacketDelayVariation(); + } + + @Test + public void testSetAvgPacketDelayVariation() throws Exception { + GtpPerFlowMetrics testSubject; + Double avgPacketDelayVariation = null; + + // default test + testSubject = createTestSubject(); + testSubject.setAvgPacketDelayVariation(avgPacketDelayVariation); + } + + @Test + public void testGetAvgPacketLatency() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getAvgPacketLatency(); + } + + @Test + public void testSetAvgPacketLatency() throws Exception { + GtpPerFlowMetrics testSubject; + Double avgPacketLatency = null; + + // default test + testSubject = createTestSubject(); + testSubject.setAvgPacketLatency(avgPacketLatency); + } + + @Test + public void testGetAvgReceiveThroughput() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getAvgReceiveThroughput(); + } + + @Test + public void testSetAvgReceiveThroughput() throws Exception { + GtpPerFlowMetrics testSubject; + Double avgReceiveThroughput = null; + + // default test + testSubject = createTestSubject(); + testSubject.setAvgReceiveThroughput(avgReceiveThroughput); + } + + @Test + public void testGetAvgTransmitThroughput() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getAvgTransmitThroughput(); + } + + @Test + public void testSetAvgTransmitThroughput() throws Exception { + GtpPerFlowMetrics testSubject; + Double avgTransmitThroughput = null; + + // default test + testSubject = createTestSubject(); + testSubject.setAvgTransmitThroughput(avgTransmitThroughput); + } + + @Test + public void testGetFlowActivationEpoch() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getFlowActivationEpoch(); + } + + @Test + public void testSetFlowActivationEpoch() throws Exception { + GtpPerFlowMetrics testSubject; + Double flowActivationEpoch = null; + + // default test + testSubject = createTestSubject(); + testSubject.setFlowActivationEpoch(flowActivationEpoch); + } + + @Test + public void testGetFlowActivationMicrosec() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getFlowActivationMicrosec(); + } + + @Test + public void testSetFlowActivationMicrosec() throws Exception { + GtpPerFlowMetrics testSubject; + Double flowActivationMicrosec = null; + + // default test + testSubject = createTestSubject(); + testSubject.setFlowActivationMicrosec(flowActivationMicrosec); + } + + @Test + public void testGetFlowDeactivationEpoch() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getFlowDeactivationEpoch(); + } + + @Test + public void testSetFlowDeactivationEpoch() throws Exception { + GtpPerFlowMetrics testSubject; + Double flowDeactivationEpoch = null; + + // default test + testSubject = createTestSubject(); + testSubject.setFlowDeactivationEpoch(flowDeactivationEpoch); + } + + @Test + public void testGetFlowDeactivationMicrosec() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getFlowDeactivationMicrosec(); + } + + @Test + public void testSetFlowDeactivationMicrosec() throws Exception { + GtpPerFlowMetrics testSubject; + Double flowDeactivationMicrosec = null; + + // default test + testSubject = createTestSubject(); + testSubject.setFlowDeactivationMicrosec(flowDeactivationMicrosec); + } + + @Test + public void testGetFlowDeactivationTime() throws Exception { + GtpPerFlowMetrics testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getFlowDeactivationTime(); + } + + @Test + public void testSetFlowDeactivationTime() throws Exception { + GtpPerFlowMetrics testSubject; + String flowDeactivationTime = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setFlowDeactivationTime(flowDeactivationTime); + } + + @Test + public void testGetFlowStatus() throws Exception { + GtpPerFlowMetrics testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getFlowStatus(); + } + + @Test + public void testSetFlowStatus() throws Exception { + GtpPerFlowMetrics testSubject; + String flowStatus = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setFlowStatus(flowStatus); + } + + @Test + public void testGetMaxPacketDelayVariation() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getMaxPacketDelayVariation(); + } + + @Test + public void testSetMaxPacketDelayVariation() throws Exception { + GtpPerFlowMetrics testSubject; + Double maxPacketDelayVariation = null; + + // default test + testSubject = createTestSubject(); + testSubject.setMaxPacketDelayVariation(maxPacketDelayVariation); + } + + @Test + public void testGetNumActivationFailures() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getNumActivationFailures(); + } + + @Test + public void testSetNumActivationFailures() throws Exception { + GtpPerFlowMetrics testSubject; + Double numActivationFailures = null; + + // default test + testSubject = createTestSubject(); + testSubject.setNumActivationFailures(numActivationFailures); + } + + @Test + public void testGetNumBitErrors() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getNumBitErrors(); + } + + @Test + public void testSetNumBitErrors() throws Exception { + GtpPerFlowMetrics testSubject; + Double numBitErrors = null; + + // default test + testSubject = createTestSubject(); + testSubject.setNumBitErrors(numBitErrors); + } + + @Test + public void testGetNumBytesReceived() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getNumBytesReceived(); + } + + @Test + public void testSetNumBytesReceived() throws Exception { + GtpPerFlowMetrics testSubject; + Double numBytesReceived = null; + + // default test + testSubject = createTestSubject(); + testSubject.setNumBytesReceived(numBytesReceived); + } + + @Test + public void testGetNumBytesTransmitted() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getNumBytesTransmitted(); + } + + @Test + public void testSetNumBytesTransmitted() throws Exception { + GtpPerFlowMetrics testSubject; + Double numBytesTransmitted = null; + + // default test + testSubject = createTestSubject(); + testSubject.setNumBytesTransmitted(numBytesTransmitted); + } + + @Test + public void testGetNumDroppedPackets() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getNumDroppedPackets(); + } + + @Test + public void testSetNumDroppedPackets() throws Exception { + GtpPerFlowMetrics testSubject; + Double numDroppedPackets = null; + + // default test + testSubject = createTestSubject(); + testSubject.setNumDroppedPackets(numDroppedPackets); + } + + @Test + public void testGetNumL7BytesReceived() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getNumL7BytesReceived(); + } + + @Test + public void testSetNumL7BytesReceived() throws Exception { + GtpPerFlowMetrics testSubject; + Double numL7BytesReceived = null; + + // default test + testSubject = createTestSubject(); + testSubject.setNumL7BytesReceived(numL7BytesReceived); + } + + @Test + public void testGetNumL7BytesTransmitted() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getNumL7BytesTransmitted(); + } + + @Test + public void testSetNumL7BytesTransmitted() throws Exception { + GtpPerFlowMetrics testSubject; + Double numL7BytesTransmitted = null; + + // default test + testSubject = createTestSubject(); + testSubject.setNumL7BytesTransmitted(numL7BytesTransmitted); + } + + @Test + public void testGetNumLostPackets() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getNumLostPackets(); + } + + @Test + public void testSetNumLostPackets() throws Exception { + GtpPerFlowMetrics testSubject; + Double numLostPackets = null; + + // default test + testSubject = createTestSubject(); + testSubject.setNumLostPackets(numLostPackets); + } + + @Test + public void testGetNumOutOfOrderPackets() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getNumOutOfOrderPackets(); + } + + @Test + public void testSetNumOutOfOrderPackets() throws Exception { + GtpPerFlowMetrics testSubject; + Double numOutOfOrderPackets = null; + + // default test + testSubject = createTestSubject(); + testSubject.setNumOutOfOrderPackets(numOutOfOrderPackets); + } + + @Test + public void testGetNumPacketErrors() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getNumPacketErrors(); + } + + @Test + public void testSetNumPacketErrors() throws Exception { + GtpPerFlowMetrics testSubject; + Double numPacketErrors = null; + + // default test + testSubject = createTestSubject(); + testSubject.setNumPacketErrors(numPacketErrors); + } + + @Test + public void testGetNumPacketsReceivedExclRetrans() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getNumPacketsReceivedExclRetrans(); + } + + @Test + public void testSetNumPacketsReceivedExclRetrans() throws Exception { + GtpPerFlowMetrics testSubject; + Double numPacketsReceivedExclRetrans = null; + + // default test + testSubject = createTestSubject(); + testSubject.setNumPacketsReceivedExclRetrans(numPacketsReceivedExclRetrans); + } + + @Test + public void testGetNumPacketsReceivedInclRetrans() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getNumPacketsReceivedInclRetrans(); + } + + @Test + public void testSetNumPacketsReceivedInclRetrans() throws Exception { + GtpPerFlowMetrics testSubject; + Double numPacketsReceivedInclRetrans = null; + + // default test + testSubject = createTestSubject(); + testSubject.setNumPacketsReceivedInclRetrans(numPacketsReceivedInclRetrans); + } + + @Test + public void testGetNumPacketsTransmittedInclRetrans() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getNumPacketsTransmittedInclRetrans(); + } + + @Test + public void testSetNumPacketsTransmittedInclRetrans() throws Exception { + GtpPerFlowMetrics testSubject; + Double numPacketsTransmittedInclRetrans = null; + + // default test + testSubject = createTestSubject(); + testSubject.setNumPacketsTransmittedInclRetrans(numPacketsTransmittedInclRetrans); + } + + @Test + public void testGetNumRetries() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getNumRetries(); + } + + @Test + public void testSetNumRetries() throws Exception { + GtpPerFlowMetrics testSubject; + Double numRetries = null; + + // default test + testSubject = createTestSubject(); + testSubject.setNumRetries(numRetries); + } + + @Test + public void testGetNumTimeouts() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getNumTimeouts(); + } + + @Test + public void testSetNumTimeouts() throws Exception { + GtpPerFlowMetrics testSubject; + Double numTimeouts = null; + + // default test + testSubject = createTestSubject(); + testSubject.setNumTimeouts(numTimeouts); + } + + @Test + public void testGetNumTunneledL7BytesReceived() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getNumTunneledL7BytesReceived(); + } + + @Test + public void testSetNumTunneledL7BytesReceived() throws Exception { + GtpPerFlowMetrics testSubject; + Double numTunneledL7BytesReceived = null; + + // default test + testSubject = createTestSubject(); + testSubject.setNumTunneledL7BytesReceived(numTunneledL7BytesReceived); + } + + @Test + public void testGetRoundTripTime() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getRoundTripTime(); + } + + @Test + public void testSetRoundTripTime() throws Exception { + GtpPerFlowMetrics testSubject; + Double roundTripTime = null; + + // default test + testSubject = createTestSubject(); + testSubject.setRoundTripTime(roundTripTime); + } + + @Test + public void testGetTimeToFirstByte() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getTimeToFirstByte(); + } + + @Test + public void testSetTimeToFirstByte() throws Exception { + GtpPerFlowMetrics testSubject; + Double timeToFirstByte = null; + + // default test + testSubject = createTestSubject(); + testSubject.setTimeToFirstByte(timeToFirstByte); + } + + @Test + public void testGetDurConnectionFailedStatus() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDurConnectionFailedStatus(); + } + + @Test + public void testSetDurConnectionFailedStatus() throws Exception { + GtpPerFlowMetrics testSubject; + Double durConnectionFailedStatus = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDurConnectionFailedStatus(durConnectionFailedStatus); + } + + @Test + public void testGetDurTunnelFailedStatus() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDurTunnelFailedStatus(); + } + + @Test + public void testSetDurTunnelFailedStatus() throws Exception { + GtpPerFlowMetrics testSubject; + Double durTunnelFailedStatus = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDurTunnelFailedStatus(durTunnelFailedStatus); + } + + @Test + public void testGetFlowActivatedBy() throws Exception { + GtpPerFlowMetrics testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getFlowActivatedBy(); + } + + @Test + public void testSetFlowActivatedBy() throws Exception { + GtpPerFlowMetrics testSubject; + String flowActivatedBy = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setFlowActivatedBy(flowActivatedBy); + } + + @Test + public void testGetFlowActivationTime() throws Exception { + GtpPerFlowMetrics testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getFlowActivationTime(); + } + + @Test + public void testSetFlowActivationTime() throws Exception { + GtpPerFlowMetrics testSubject; + String flowActivationTime = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setFlowActivationTime(flowActivationTime); + } + + @Test + public void testGetFlowDeactivatedBy() throws Exception { + GtpPerFlowMetrics testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getFlowDeactivatedBy(); + } + + @Test + public void testSetFlowDeactivatedBy() throws Exception { + GtpPerFlowMetrics testSubject; + String flowDeactivatedBy = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setFlowDeactivatedBy(flowDeactivatedBy); + } + + @Test + public void testGetGtpConnectionStatus() throws Exception { + GtpPerFlowMetrics testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getGtpConnectionStatus(); + } + + @Test + public void testSetGtpConnectionStatus() throws Exception { + GtpPerFlowMetrics testSubject; + String gtpConnectionStatus = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setGtpConnectionStatus(gtpConnectionStatus); + } + + @Test + public void testGetGtpTunnelStatus() throws Exception { + GtpPerFlowMetrics testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getGtpTunnelStatus(); + } + + @Test + public void testSetGtpTunnelStatus() throws Exception { + GtpPerFlowMetrics testSubject; + String gtpTunnelStatus = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setGtpTunnelStatus(gtpTunnelStatus); + } + + @Test + public void testGetIpTosCountList() throws Exception { + GtpPerFlowMetrics testSubject; + List<List<String>> result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getIpTosCountList(); + } + + @Test + public void testSetIpTosCountList() throws Exception { + GtpPerFlowMetrics testSubject; + List<List<String>> ipTosCountList = null; + + // default test + testSubject = createTestSubject(); + testSubject.setIpTosCountList(ipTosCountList); + } + + @Test + public void testGetIpTosList() throws Exception { + GtpPerFlowMetrics testSubject; + List<String> result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getIpTosList(); + } + + @Test + public void testSetIpTosList() throws Exception { + GtpPerFlowMetrics testSubject; + List<String> ipTosList = null; + + // default test + testSubject = createTestSubject(); + testSubject.setIpTosList(ipTosList); + } + + @Test + public void testGetLargePacketRtt() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getLargePacketRtt(); + } + + @Test + public void testSetLargePacketRtt() throws Exception { + GtpPerFlowMetrics testSubject; + Double largePacketRtt = null; + + // default test + testSubject = createTestSubject(); + testSubject.setLargePacketRtt(largePacketRtt); + } + + @Test + public void testGetLargePacketThreshold() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getLargePacketThreshold(); + } + + @Test + public void testSetLargePacketThreshold() throws Exception { + GtpPerFlowMetrics testSubject; + Double largePacketThreshold = null; + + // default test + testSubject = createTestSubject(); + testSubject.setLargePacketThreshold(largePacketThreshold); + } + + @Test + public void testGetMaxReceiveBitRate() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getMaxReceiveBitRate(); + } + + @Test + public void testSetMaxReceiveBitRate() throws Exception { + GtpPerFlowMetrics testSubject; + Double maxReceiveBitRate = null; + + // default test + testSubject = createTestSubject(); + testSubject.setMaxReceiveBitRate(maxReceiveBitRate); + } + + @Test + public void testGetMaxTransmitBitRate() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getMaxTransmitBitRate(); + } + + @Test + public void testSetMaxTransmitBitRate() throws Exception { + GtpPerFlowMetrics testSubject; + Double maxTransmitBitRate = null; + + // default test + testSubject = createTestSubject(); + testSubject.setMaxTransmitBitRate(maxTransmitBitRate); + } + + @Test + public void testGetMobileQciCosCountList() throws Exception { + GtpPerFlowMetrics testSubject; + List<List<String>> result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getMobileQciCosCountList(); + } + + @Test + public void testSetMobileQciCosCountList() throws Exception { + GtpPerFlowMetrics testSubject; + List<List<String>> mobileQciCosCountList = null; + + // default test + testSubject = createTestSubject(); + testSubject.setMobileQciCosCountList(mobileQciCosCountList); + } + + @Test + public void testGetMobileQciCosList() throws Exception { + GtpPerFlowMetrics testSubject; + List<String> result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getMobileQciCosList(); + } + + @Test + public void testSetMobileQciCosList() throws Exception { + GtpPerFlowMetrics testSubject; + List<String> mobileQciCosList = null; + + // default test + testSubject = createTestSubject(); + testSubject.setMobileQciCosList(mobileQciCosList); + } + + @Test + public void testGetNumGtpEchoFailures() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getNumGtpEchoFailures(); + } + + @Test + public void testSetNumGtpEchoFailures() throws Exception { + GtpPerFlowMetrics testSubject; + Double numGtpEchoFailures = null; + + // default test + testSubject = createTestSubject(); + testSubject.setNumGtpEchoFailures(numGtpEchoFailures); + } + + @Test + public void testGetNumGtpTunnelErrors() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getNumGtpTunnelErrors(); + } + + @Test + public void testSetNumGtpTunnelErrors() throws Exception { + GtpPerFlowMetrics testSubject; + Double numGtpTunnelErrors = null; + + // default test + testSubject = createTestSubject(); + testSubject.setNumGtpTunnelErrors(numGtpTunnelErrors); + } + + @Test + public void testGetNumHttpErrors() throws Exception { + GtpPerFlowMetrics testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getNumHttpErrors(); + } + + @Test + public void testSetNumHttpErrors() throws Exception { + GtpPerFlowMetrics testSubject; + Double numHttpErrors = null; + + // default test + testSubject = createTestSubject(); + testSubject.setNumHttpErrors(numHttpErrors); + } + + @Test + public void testGetTcpFlagCountList() throws Exception { + GtpPerFlowMetrics testSubject; + List<List<String>> result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getTcpFlagCountList(); + } + + @Test + public void testSetTcpFlagCountList() throws Exception { + GtpPerFlowMetrics testSubject; + List<List<String>> tcpFlagCountList = null; + + // default test + testSubject = createTestSubject(); + testSubject.setTcpFlagCountList(tcpFlagCountList); + } + + @Test + public void testGetTcpFlagList() throws Exception { + GtpPerFlowMetrics testSubject; + List<String> result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getTcpFlagList(); + } + + @Test + public void testSetTcpFlagList() throws Exception { + GtpPerFlowMetrics testSubject; + List<String> tcpFlagList = null; + + // default test + testSubject = createTestSubject(); + testSubject.setTcpFlagList(tcpFlagList); + } + + @Test + public void testGetAdditionalProperties() throws Exception { + GtpPerFlowMetrics testSubject; + Map<String, Object> result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getAdditionalProperties(); + } + + @Test + public void testSetAdditionalProperty() throws Exception { + GtpPerFlowMetrics testSubject; + String name = ""; + Object value = null; + + // default test + testSubject = createTestSubject(); + testSubject.setAdditionalProperty(name, value); + } + + @Test + public void testToString() throws Exception { + GtpPerFlowMetrics testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.toString(); + } + + @Test + public void testHashCode() throws Exception { + GtpPerFlowMetrics testSubject; + int result; + + // default test + testSubject = createTestSubject(); + result = testSubject.hashCode(); + } + + @Test + public void testEquals() throws Exception { + GtpPerFlowMetrics testSubject; + Object other = null; + boolean result; + + // default test + testSubject = createTestSubject(); + result = testSubject.equals(other); + } +}
\ No newline at end of file diff --git a/UniversalVesAdapter/src/test/java/org/onap/dcaegen2/ves/domain/JsonObjectTest.java b/UniversalVesAdapter/src/test/java/org/onap/dcaegen2/ves/domain/JsonObjectTest.java new file mode 100644 index 0000000..9a57ae1 --- /dev/null +++ b/UniversalVesAdapter/src/test/java/org/onap/dcaegen2/ves/domain/JsonObjectTest.java @@ -0,0 +1,204 @@ +/* +* ============LICENSE_START======================================================= +* ONAP : DCAE +* ================================================================================ +* Copyright 2018 TechMahindra +*================================================================================= +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +* ============LICENSE_END========================================================= +*/ +package org.onap.dcaegen2.ves.domain; + +import java.util.List; +import java.util.Map; + +import org.junit.Test; + +public class JsonObjectTest { + + private JsonObject createTestSubject() { + return new JsonObject(); + } + + @Test + public void testGetObjectInstances() throws Exception { + JsonObject testSubject; + List<ObjectInstance> result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getObjectInstances(); + } + + @Test + public void testSetObjectInstances() throws Exception { + JsonObject testSubject; + List<ObjectInstance> objectInstances = null; + + // default test + testSubject = createTestSubject(); + testSubject.setObjectInstances(objectInstances); + } + + @Test + public void testGetObjectName() throws Exception { + JsonObject testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getObjectName(); + } + + @Test + public void testSetObjectName() throws Exception { + JsonObject testSubject; + String objectName = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setObjectName(objectName); + } + + @Test + public void testGetObjectSchema() throws Exception { + JsonObject testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getObjectSchema(); + } + + @Test + public void testSetObjectSchema() throws Exception { + JsonObject testSubject; + String objectSchema = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setObjectSchema(objectSchema); + } + + @Test + public void testGetObjectSchemaUrl() throws Exception { + JsonObject testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getObjectSchemaUrl(); + } + + @Test + public void testSetObjectSchemaUrl() throws Exception { + JsonObject testSubject; + String objectSchemaUrl = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setObjectSchemaUrl(objectSchemaUrl); + } + + @Test + public void testGetNfSubscribedObjectName() throws Exception { + JsonObject testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getNfSubscribedObjectName(); + } + + @Test + public void testSetNfSubscribedObjectName() throws Exception { + JsonObject testSubject; + String nfSubscribedObjectName = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setNfSubscribedObjectName(nfSubscribedObjectName); + } + + @Test + public void testGetNfSubscriptionId() throws Exception { + JsonObject testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getNfSubscriptionId(); + } + + @Test + public void testSetNfSubscriptionId() throws Exception { + JsonObject testSubject; + String nfSubscriptionId = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setNfSubscriptionId(nfSubscriptionId); + } + + @Test + public void testGetAdditionalProperties() throws Exception { + JsonObject testSubject; + Map<String, Object> result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getAdditionalProperties(); + } + + @Test + public void testSetAdditionalProperty() throws Exception { + JsonObject testSubject; + String name = ""; + Object value = null; + + // default test + testSubject = createTestSubject(); + testSubject.setAdditionalProperty(name, value); + } + + @Test + public void testToString() throws Exception { + JsonObject testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.toString(); + } + + @Test + public void testHashCode() throws Exception { + JsonObject testSubject; + int result; + + // default test + testSubject = createTestSubject(); + result = testSubject.hashCode(); + } + + @Test + public void testEquals() throws Exception { + JsonObject testSubject; + Object other = null; + boolean result; + + // default test + testSubject = createTestSubject(); + result = testSubject.equals(other); + } +}
\ No newline at end of file diff --git a/UniversalVesAdapter/src/test/java/org/onap/dcaegen2/ves/domain/LatencyDistributionTest.java b/UniversalVesAdapter/src/test/java/org/onap/dcaegen2/ves/domain/LatencyDistributionTest.java new file mode 100644 index 0000000..01422d6 --- /dev/null +++ b/UniversalVesAdapter/src/test/java/org/onap/dcaegen2/ves/domain/LatencyDistributionTest.java @@ -0,0 +1,143 @@ +/* +* ============LICENSE_START======================================================= +* ONAP : DCAE +* ================================================================================ +* Copyright 2018 TechMahindra +*================================================================================= +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +* ============LICENSE_END========================================================= +*/ +package org.onap.dcaegen2.ves.domain; + +import java.util.Map; +import org.onap.dcaegen2.ves.domain.LatencyDistribution; +import org.junit.Test; + +public class LatencyDistributionTest { + + private LatencyDistribution createTestSubject() { + return new LatencyDistribution(); + } + + @Test + public void testGetCountsInTheBucket() throws Exception { + LatencyDistribution testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getCountsInTheBucket(); + } + + @Test + public void testSetCountsInTheBucket() throws Exception { + LatencyDistribution testSubject; + Double countsInTheBucket = null; + + // default test + testSubject = createTestSubject(); + testSubject.setCountsInTheBucket(countsInTheBucket); + } + + @Test + public void testGetHighEndOfLatencyBucket() throws Exception { + LatencyDistribution testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getHighEndOfLatencyBucket(); + } + + @Test + public void testSetHighEndOfLatencyBucket() throws Exception { + LatencyDistribution testSubject; + Double highEndOfLatencyBucket = null; + + // default test + testSubject = createTestSubject(); + testSubject.setHighEndOfLatencyBucket(highEndOfLatencyBucket); + } + + @Test + public void testGetLowEndOfLatencyBucket() throws Exception { + LatencyDistribution testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getLowEndOfLatencyBucket(); + } + + @Test + public void testSetLowEndOfLatencyBucket() throws Exception { + LatencyDistribution testSubject; + Double lowEndOfLatencyBucket = null; + + // default test + testSubject = createTestSubject(); + testSubject.setLowEndOfLatencyBucket(lowEndOfLatencyBucket); + } + + @Test + public void testGetAdditionalProperties() throws Exception { + LatencyDistribution testSubject; + Map<String, Object> result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getAdditionalProperties(); + } + + @Test + public void testSetAdditionalProperty() throws Exception { + LatencyDistribution testSubject; + String name = ""; + Object value = null; + + // default test + testSubject = createTestSubject(); + testSubject.setAdditionalProperty(name, value); + } + + @Test + public void testToString() throws Exception { + LatencyDistribution testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.toString(); + } + + @Test + public void testHashCode() throws Exception { + LatencyDistribution testSubject; + int result; + + // default test + testSubject = createTestSubject(); + result = testSubject.hashCode(); + } + + @Test + public void testEquals() throws Exception { + LatencyDistribution testSubject; + Object other = null; + boolean result; + + // default test + testSubject = createTestSubject(); + result = testSubject.equals(other); + } +}
\ No newline at end of file diff --git a/UniversalVesAdapter/src/test/java/org/onap/dcaegen2/ves/domain/MeasurementsForVfScalingFieldsTest.java b/UniversalVesAdapter/src/test/java/org/onap/dcaegen2/ves/domain/MeasurementsForVfScalingFieldsTest.java new file mode 100644 index 0000000..7c6b78a --- /dev/null +++ b/UniversalVesAdapter/src/test/java/org/onap/dcaegen2/ves/domain/MeasurementsForVfScalingFieldsTest.java @@ -0,0 +1,464 @@ +/* +* ============LICENSE_START======================================================= +* ONAP : DCAE +* ================================================================================ +* Copyright 2018 TechMahindra +*================================================================================= +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +* ============LICENSE_END========================================================= +*/ +package org.onap.dcaegen2.ves.domain; + +import java.util.List; +import java.util.Map; +import org.onap.dcaegen2.ves.domain.MeasurementsForVfScalingFields; +import org.junit.Test; + +public class MeasurementsForVfScalingFieldsTest { + + private MeasurementsForVfScalingFields createTestSubject() { + return new MeasurementsForVfScalingFields(); + } + + @Test + public void testGetMeasurementInterval() throws Exception { + MeasurementsForVfScalingFields testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getMeasurementInterval(); + } + + @Test + public void testSetMeasurementInterval() throws Exception { + MeasurementsForVfScalingFields testSubject; + Double measurementInterval = null; + + // default test + testSubject = createTestSubject(); + testSubject.setMeasurementInterval(measurementInterval); + } + + @Test + public void testGetMeasurementsForVfScalingVersion() throws Exception { + MeasurementsForVfScalingFields testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getMeasurementsForVfScalingVersion(); + } + + @Test + public void testSetMeasurementsForVfScalingVersion() throws Exception { + MeasurementsForVfScalingFields testSubject; + Double measurementsForVfScalingVersion = null; + + // default test + testSubject = createTestSubject(); + testSubject.setMeasurementsForVfScalingVersion(measurementsForVfScalingVersion); + } + + @Test + public void testGetAdditionalFields() throws Exception { + MeasurementsForVfScalingFields testSubject; + List<AdditionalField> result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getAdditionalFields(); + } + + @Test + public void testSetAdditionalFields() throws Exception { + MeasurementsForVfScalingFields testSubject; + List<AdditionalField> additionalFields = null; + + // default test + testSubject = createTestSubject(); + testSubject.setAdditionalFields(additionalFields); + } + + @Test + public void testGetAdditionalMeasurements() throws Exception { + MeasurementsForVfScalingFields testSubject; + List<AdditionalMeasurement> result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getAdditionalMeasurements(); + } + + @Test + public void testSetAdditionalMeasurements() throws Exception { + MeasurementsForVfScalingFields testSubject; + List<AdditionalMeasurement> additionalMeasurements = null; + + // default test + testSubject = createTestSubject(); + testSubject.setAdditionalMeasurements(additionalMeasurements); + } + + @Test + public void testGetAdditionalObjects() throws Exception { + MeasurementsForVfScalingFields testSubject; + List<AdditionalObject> result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getAdditionalObjects(); + } + + @Test + public void testSetAdditionalObjects() throws Exception { + MeasurementsForVfScalingFields testSubject; + List<AdditionalObject> additionalObjects = null; + + // default test + testSubject = createTestSubject(); + testSubject.setAdditionalObjects(additionalObjects); + } + + @Test + public void testGetCodecUsageArray() throws Exception { + MeasurementsForVfScalingFields testSubject; + List<CodecUsageArray> result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getCodecUsageArray(); + } + + @Test + public void testSetCodecUsageArray() throws Exception { + MeasurementsForVfScalingFields testSubject; + List<CodecUsageArray> codecUsageArray = null; + + // default test + testSubject = createTestSubject(); + testSubject.setCodecUsageArray(codecUsageArray); + } + + @Test + public void testGetConcurrentSessions() throws Exception { + MeasurementsForVfScalingFields testSubject; + Long result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getConcurrentSessions(); + } + + @Test + public void testSetConcurrentSessions() throws Exception { + MeasurementsForVfScalingFields testSubject; + Long concurrentSessions = null; + + // default test + testSubject = createTestSubject(); + testSubject.setConcurrentSessions(concurrentSessions); + } + + @Test + public void testGetConfiguredEntities() throws Exception { + MeasurementsForVfScalingFields testSubject; + Long result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getConfiguredEntities(); + } + + @Test + public void testSetConfiguredEntities() throws Exception { + MeasurementsForVfScalingFields testSubject; + Long configuredEntities = null; + + // default test + testSubject = createTestSubject(); + testSubject.setConfiguredEntities(configuredEntities); + } + + @Test + public void testGetCpuUsageArray() throws Exception { + MeasurementsForVfScalingFields testSubject; + List<CpuUsageArray> result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getCpuUsageArray(); + } + + @Test + public void testSetCpuUsageArray() throws Exception { + MeasurementsForVfScalingFields testSubject; + List<CpuUsageArray> cpuUsageArray = null; + + // default test + testSubject = createTestSubject(); + testSubject.setCpuUsageArray(cpuUsageArray); + } + + @Test + public void testGetDiskUsageArray() throws Exception { + MeasurementsForVfScalingFields testSubject; + List<DiskUsageArray> result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getDiskUsageArray(); + } + + @Test + public void testSetDiskUsageArray() throws Exception { + MeasurementsForVfScalingFields testSubject; + List<DiskUsageArray> diskUsageArray = null; + + // default test + testSubject = createTestSubject(); + testSubject.setDiskUsageArray(diskUsageArray); + } + + @Test + public void testGetFeatureUsageArray() throws Exception { + MeasurementsForVfScalingFields testSubject; + List<FeatureUsageArray> result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getFeatureUsageArray(); + } + + @Test + public void testSetFeatureUsageArray() throws Exception { + MeasurementsForVfScalingFields testSubject; + List<FeatureUsageArray> featureUsageArray = null; + + // default test + testSubject = createTestSubject(); + testSubject.setFeatureUsageArray(featureUsageArray); + } + + @Test + public void testGetFilesystemUsageArray() throws Exception { + MeasurementsForVfScalingFields testSubject; + List<FilesystemUsageArray> result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getFilesystemUsageArray(); + } + + @Test + public void testSetFilesystemUsageArray() throws Exception { + MeasurementsForVfScalingFields testSubject; + List<FilesystemUsageArray> filesystemUsageArray = null; + + // default test + testSubject = createTestSubject(); + testSubject.setFilesystemUsageArray(filesystemUsageArray); + } + + @Test + public void testGetLatencyDistribution() throws Exception { + MeasurementsForVfScalingFields testSubject; + List<LatencyDistribution> result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getLatencyDistribution(); + } + + @Test + public void testSetLatencyDistribution() throws Exception { + MeasurementsForVfScalingFields testSubject; + List<LatencyDistribution> latencyDistribution = null; + + // default test + testSubject = createTestSubject(); + testSubject.setLatencyDistribution(latencyDistribution); + } + + @Test + public void testGetMeanRequestLatency() throws Exception { + MeasurementsForVfScalingFields testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getMeanRequestLatency(); + } + + @Test + public void testSetMeanRequestLatency() throws Exception { + MeasurementsForVfScalingFields testSubject; + Double meanRequestLatency = null; + + // default test + testSubject = createTestSubject(); + testSubject.setMeanRequestLatency(meanRequestLatency); + } + + @Test + public void testGetMemoryUsageArray() throws Exception { + MeasurementsForVfScalingFields testSubject; + List<MemoryUsageArray> result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getMemoryUsageArray(); + } + + @Test + public void testSetMemoryUsageArray() throws Exception { + MeasurementsForVfScalingFields testSubject; + List<MemoryUsageArray> memoryUsageArray = null; + + // default test + testSubject = createTestSubject(); + testSubject.setMemoryUsageArray(memoryUsageArray); + } + + @Test + public void testGetNumberOfMediaPortsInUse() throws Exception { + MeasurementsForVfScalingFields testSubject; + Long result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getNumberOfMediaPortsInUse(); + } + + @Test + public void testSetNumberOfMediaPortsInUse() throws Exception { + MeasurementsForVfScalingFields testSubject; + Long numberOfMediaPortsInUse = null; + + // default test + testSubject = createTestSubject(); + testSubject.setNumberOfMediaPortsInUse(numberOfMediaPortsInUse); + } + + @Test + public void testGetRequestRate() throws Exception { + MeasurementsForVfScalingFields testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getRequestRate(); + } + + @Test + public void testSetRequestRate() throws Exception { + MeasurementsForVfScalingFields testSubject; + Double requestRate = null; + + // default test + testSubject = createTestSubject(); + testSubject.setRequestRate(requestRate); + } + + @Test + public void testGetVnfcScalingMetric() throws Exception { + MeasurementsForVfScalingFields testSubject; + Long result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getVnfcScalingMetric(); + } + + @Test + public void testSetVnfcScalingMetric() throws Exception { + MeasurementsForVfScalingFields testSubject; + Long vnfcScalingMetric = null; + + // default test + testSubject = createTestSubject(); + testSubject.setVnfcScalingMetric(vnfcScalingMetric); + } + + @Test + public void testGetVNicPerformanceArray() throws Exception { + MeasurementsForVfScalingFields testSubject; + List<VNicPerformanceArray> result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getVNicPerformanceArray(); + } + + @Test + public void testSetVNicPerformanceArray() throws Exception { + MeasurementsForVfScalingFields testSubject; + List<VNicPerformanceArray> vNicPerformanceArray = null; + + // default test + testSubject = createTestSubject(); + testSubject.setVNicPerformanceArray(vNicPerformanceArray); + } + + @Test + public void testGetAdditionalProperties() throws Exception { + MeasurementsForVfScalingFields testSubject; + Map<String, Object> result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getAdditionalProperties(); + } + + @Test + public void testSetAdditionalProperty() throws Exception { + MeasurementsForVfScalingFields testSubject; + String name = ""; + Object value = null; + + // default test + testSubject = createTestSubject(); + testSubject.setAdditionalProperty(name, value); + } + + @Test + public void testToString() throws Exception { + MeasurementsForVfScalingFields testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.toString(); + } + + @Test + public void testHashCode() throws Exception { + MeasurementsForVfScalingFields testSubject; + int result; + + // default test + testSubject = createTestSubject(); + result = testSubject.hashCode(); + } + + @Test + public void testEquals() throws Exception { + MeasurementsForVfScalingFields testSubject; + Object other = null; + boolean result; + + // default test + testSubject = createTestSubject(); + result = testSubject.equals(other); + } +}
\ No newline at end of file diff --git a/UniversalVesAdapter/src/test/java/org/onap/dcaegen2/ves/domain/MemoryUsageArrayTest.java b/UniversalVesAdapter/src/test/java/org/onap/dcaegen2/ves/domain/MemoryUsageArrayTest.java new file mode 100644 index 0000000..ffac3e2 --- /dev/null +++ b/UniversalVesAdapter/src/test/java/org/onap/dcaegen2/ves/domain/MemoryUsageArrayTest.java @@ -0,0 +1,243 @@ +/* +* ============LICENSE_START======================================================= +* ONAP : DCAE +* ================================================================================ +* Copyright 2018 TechMahindra +*================================================================================= +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +* ============LICENSE_END========================================================= +*/ +package org.onap.dcaegen2.ves.domain; + +import java.util.Map; + +import org.junit.Test; + +public class MemoryUsageArrayTest { + + private MemoryUsageArray createTestSubject() { + return new MemoryUsageArray(); + } + + @Test + public void testGetMemoryFree() throws Exception { + MemoryUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getMemoryFree(); + } + + @Test + public void testSetMemoryFree() throws Exception { + MemoryUsageArray testSubject; + Double memoryFree = null; + + // default test + testSubject = createTestSubject(); + testSubject.setMemoryFree(memoryFree); + } + + @Test + public void testGetMemoryUsed() throws Exception { + MemoryUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getMemoryUsed(); + } + + @Test + public void testSetMemoryUsed() throws Exception { + MemoryUsageArray testSubject; + Double memoryUsed = null; + + // default test + testSubject = createTestSubject(); + testSubject.setMemoryUsed(memoryUsed); + } + + @Test + public void testGetVmIdentifier() throws Exception { + MemoryUsageArray testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getVmIdentifier(); + } + + @Test + public void testSetVmIdentifier() throws Exception { + MemoryUsageArray testSubject; + String vmIdentifier = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setVmIdentifier(vmIdentifier); + } + + @Test + public void testGetMemoryBuffered() throws Exception { + MemoryUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getMemoryBuffered(); + } + + @Test + public void testSetMemoryBuffered() throws Exception { + MemoryUsageArray testSubject; + Double memoryBuffered = null; + + // default test + testSubject = createTestSubject(); + testSubject.setMemoryBuffered(memoryBuffered); + } + + @Test + public void testGetMemoryCached() throws Exception { + MemoryUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getMemoryCached(); + } + + @Test + public void testSetMemoryCached() throws Exception { + MemoryUsageArray testSubject; + Double memoryCached = null; + + // default test + testSubject = createTestSubject(); + testSubject.setMemoryCached(memoryCached); + } + + @Test + public void testGetMemoryConfigured() throws Exception { + MemoryUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getMemoryConfigured(); + } + + @Test + public void testSetMemoryConfigured() throws Exception { + MemoryUsageArray testSubject; + Double memoryConfigured = null; + + // default test + testSubject = createTestSubject(); + testSubject.setMemoryConfigured(memoryConfigured); + } + + @Test + public void testGetMemorySlabRecl() throws Exception { + MemoryUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getMemorySlabRecl(); + } + + @Test + public void testSetMemorySlabRecl() throws Exception { + MemoryUsageArray testSubject; + Double memorySlabRecl = null; + + // default test + testSubject = createTestSubject(); + testSubject.setMemorySlabRecl(memorySlabRecl); + } + + @Test + public void testGetMemorySlabUnrecl() throws Exception { + MemoryUsageArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getMemorySlabUnrecl(); + } + + @Test + public void testSetMemorySlabUnrecl() throws Exception { + MemoryUsageArray testSubject; + Double memorySlabUnrecl = null; + + // default test + testSubject = createTestSubject(); + testSubject.setMemorySlabUnrecl(memorySlabUnrecl); + } + + @Test + public void testGetAdditionalProperties() throws Exception { + MemoryUsageArray testSubject; + Map<String, Object> result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getAdditionalProperties(); + } + + @Test + public void testSetAdditionalProperty() throws Exception { + MemoryUsageArray testSubject; + String name = ""; + Object value = null; + + // default test + testSubject = createTestSubject(); + testSubject.setAdditionalProperty(name, value); + } + + @Test + public void testToString() throws Exception { + MemoryUsageArray testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.toString(); + } + + @Test + public void testHashCode() throws Exception { + MemoryUsageArray testSubject; + int result; + + // default test + testSubject = createTestSubject(); + result = testSubject.hashCode(); + } + + @Test + public void testEquals() throws Exception { + MemoryUsageArray testSubject; + Object other = null; + boolean result; + + // default test + testSubject = createTestSubject(); + result = testSubject.equals(other); + } +}
\ No newline at end of file diff --git a/UniversalVesAdapter/src/test/java/org/onap/dcaegen2/ves/domain/MobileFlowFieldsTest.java b/UniversalVesAdapter/src/test/java/org/onap/dcaegen2/ves/domain/MobileFlowFieldsTest.java new file mode 100644 index 0000000..dc7431f --- /dev/null +++ b/UniversalVesAdapter/src/test/java/org/onap/dcaegen2/ves/domain/MobileFlowFieldsTest.java @@ -0,0 +1,744 @@ +/* +* ============LICENSE_START======================================================= +* ONAP : DCAE +* ================================================================================ +* Copyright 2018 TechMahindra +*================================================================================= +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +* ============LICENSE_END========================================================= +*/ +package org.onap.dcaegen2.ves.domain; + +import java.util.List; +import java.util.Map; + +import org.junit.Test; + +public class MobileFlowFieldsTest { + + private MobileFlowFields createTestSubject() { + return new MobileFlowFields(); + } + + @Test + public void testGetFlowDirection() throws Exception { + MobileFlowFields testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getFlowDirection(); + } + + @Test + public void testSetFlowDirection() throws Exception { + MobileFlowFields testSubject; + String flowDirection = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setFlowDirection(flowDirection); + } + + @Test + public void testGetGtpPerFlowMetrics() throws Exception { + MobileFlowFields testSubject; + GtpPerFlowMetrics result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getGtpPerFlowMetrics(); + } + + @Test + public void testSetGtpPerFlowMetrics() throws Exception { + MobileFlowFields testSubject; + GtpPerFlowMetrics gtpPerFlowMetrics = null; + + // default test + testSubject = createTestSubject(); + testSubject.setGtpPerFlowMetrics(gtpPerFlowMetrics); + } + + @Test + public void testGetIpProtocolType() throws Exception { + MobileFlowFields testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getIpProtocolType(); + } + + @Test + public void testSetIpProtocolType() throws Exception { + MobileFlowFields testSubject; + String ipProtocolType = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setIpProtocolType(ipProtocolType); + } + + @Test + public void testGetIpVersion() throws Exception { + MobileFlowFields testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getIpVersion(); + } + + @Test + public void testSetIpVersion() throws Exception { + MobileFlowFields testSubject; + String ipVersion = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setIpVersion(ipVersion); + } + + @Test + public void testGetMobileFlowFieldsVersion() throws Exception { + MobileFlowFields testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getMobileFlowFieldsVersion(); + } + + @Test + public void testSetMobileFlowFieldsVersion() throws Exception { + MobileFlowFields testSubject; + Double mobileFlowFieldsVersion = null; + + // default test + testSubject = createTestSubject(); + testSubject.setMobileFlowFieldsVersion(mobileFlowFieldsVersion); + } + + @Test + public void testGetOtherEndpointIpAddress() throws Exception { + MobileFlowFields testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getOtherEndpointIpAddress(); + } + + @Test + public void testSetOtherEndpointIpAddress() throws Exception { + MobileFlowFields testSubject; + String otherEndpointIpAddress = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setOtherEndpointIpAddress(otherEndpointIpAddress); + } + + @Test + public void testGetOtherEndpointPort() throws Exception { + MobileFlowFields testSubject; + Long result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getOtherEndpointPort(); + } + + @Test + public void testSetOtherEndpointPort() throws Exception { + MobileFlowFields testSubject; + Long otherEndpointPort = null; + + // default test + testSubject = createTestSubject(); + testSubject.setOtherEndpointPort(otherEndpointPort); + } + + @Test + public void testGetReportingEndpointIpAddr() throws Exception { + MobileFlowFields testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getReportingEndpointIpAddr(); + } + + @Test + public void testSetReportingEndpointIpAddr() throws Exception { + MobileFlowFields testSubject; + String reportingEndpointIpAddr = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setReportingEndpointIpAddr(reportingEndpointIpAddr); + } + + @Test + public void testGetReportingEndpointPort() throws Exception { + MobileFlowFields testSubject; + Long result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getReportingEndpointPort(); + } + + @Test + public void testSetReportingEndpointPort() throws Exception { + MobileFlowFields testSubject; + Long reportingEndpointPort = null; + + // default test + testSubject = createTestSubject(); + testSubject.setReportingEndpointPort(reportingEndpointPort); + } + + @Test + public void testGetAdditionalFields() throws Exception { + MobileFlowFields testSubject; + List<AdditionalField> result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getAdditionalFields(); + } + + @Test + public void testSetAdditionalFields() throws Exception { + MobileFlowFields testSubject; + List<AdditionalField> additionalFields = null; + + // default test + testSubject = createTestSubject(); + testSubject.setAdditionalFields(additionalFields); + } + + @Test + public void testGetApplicationType() throws Exception { + MobileFlowFields testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getApplicationType(); + } + + @Test + public void testSetApplicationType() throws Exception { + MobileFlowFields testSubject; + String applicationType = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setApplicationType(applicationType); + } + + @Test + public void testGetAppProtocolType() throws Exception { + MobileFlowFields testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getAppProtocolType(); + } + + @Test + public void testSetAppProtocolType() throws Exception { + MobileFlowFields testSubject; + String appProtocolType = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setAppProtocolType(appProtocolType); + } + + @Test + public void testGetAppProtocolVersion() throws Exception { + MobileFlowFields testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getAppProtocolVersion(); + } + + @Test + public void testSetAppProtocolVersion() throws Exception { + MobileFlowFields testSubject; + String appProtocolVersion = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setAppProtocolVersion(appProtocolVersion); + } + + @Test + public void testGetCid() throws Exception { + MobileFlowFields testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getCid(); + } + + @Test + public void testSetCid() throws Exception { + MobileFlowFields testSubject; + String cid = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setCid(cid); + } + + @Test + public void testGetConnectionType() throws Exception { + MobileFlowFields testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getConnectionType(); + } + + @Test + public void testSetConnectionType() throws Exception { + MobileFlowFields testSubject; + String connectionType = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setConnectionType(connectionType); + } + + @Test + public void testGetEcgi() throws Exception { + MobileFlowFields testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getEcgi(); + } + + @Test + public void testSetEcgi() throws Exception { + MobileFlowFields testSubject; + String ecgi = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setEcgi(ecgi); + } + + @Test + public void testGetGtpProtocolType() throws Exception { + MobileFlowFields testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getGtpProtocolType(); + } + + @Test + public void testSetGtpProtocolType() throws Exception { + MobileFlowFields testSubject; + String gtpProtocolType = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setGtpProtocolType(gtpProtocolType); + } + + @Test + public void testGetGtpVersion() throws Exception { + MobileFlowFields testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getGtpVersion(); + } + + @Test + public void testSetGtpVersion() throws Exception { + MobileFlowFields testSubject; + String gtpVersion = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setGtpVersion(gtpVersion); + } + + @Test + public void testGetHttpHeader() throws Exception { + MobileFlowFields testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getHttpHeader(); + } + + @Test + public void testSetHttpHeader() throws Exception { + MobileFlowFields testSubject; + String httpHeader = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setHttpHeader(httpHeader); + } + + @Test + public void testGetImei() throws Exception { + MobileFlowFields testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getImei(); + } + + @Test + public void testSetImei() throws Exception { + MobileFlowFields testSubject; + String imei = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setImei(imei); + } + + @Test + public void testGetImsi() throws Exception { + MobileFlowFields testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getImsi(); + } + + @Test + public void testSetImsi() throws Exception { + MobileFlowFields testSubject; + String imsi = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setImsi(imsi); + } + + @Test + public void testGetLac() throws Exception { + MobileFlowFields testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getLac(); + } + + @Test + public void testSetLac() throws Exception { + MobileFlowFields testSubject; + String lac = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setLac(lac); + } + + @Test + public void testGetMcc() throws Exception { + MobileFlowFields testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getMcc(); + } + + @Test + public void testSetMcc() throws Exception { + MobileFlowFields testSubject; + String mcc = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setMcc(mcc); + } + + @Test + public void testGetMnc() throws Exception { + MobileFlowFields testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getMnc(); + } + + @Test + public void testSetMnc() throws Exception { + MobileFlowFields testSubject; + String mnc = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setMnc(mnc); + } + + @Test + public void testGetMsisdn() throws Exception { + MobileFlowFields testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getMsisdn(); + } + + @Test + public void testSetMsisdn() throws Exception { + MobileFlowFields testSubject; + String msisdn = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setMsisdn(msisdn); + } + + @Test + public void testGetOtherFunctionalRole() throws Exception { + MobileFlowFields testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getOtherFunctionalRole(); + } + + @Test + public void testSetOtherFunctionalRole() throws Exception { + MobileFlowFields testSubject; + String otherFunctionalRole = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setOtherFunctionalRole(otherFunctionalRole); + } + + @Test + public void testGetRac() throws Exception { + MobileFlowFields testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getRac(); + } + + @Test + public void testSetRac() throws Exception { + MobileFlowFields testSubject; + String rac = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setRac(rac); + } + + @Test + public void testGetRadioAccessTechnology() throws Exception { + MobileFlowFields testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getRadioAccessTechnology(); + } + + @Test + public void testSetRadioAccessTechnology() throws Exception { + MobileFlowFields testSubject; + String radioAccessTechnology = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setRadioAccessTechnology(radioAccessTechnology); + } + + @Test + public void testGetSac() throws Exception { + MobileFlowFields testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getSac(); + } + + @Test + public void testSetSac() throws Exception { + MobileFlowFields testSubject; + String sac = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setSac(sac); + } + + @Test + public void testGetSamplingAlgorithm() throws Exception { + MobileFlowFields testSubject; + Long result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getSamplingAlgorithm(); + } + + @Test + public void testSetSamplingAlgorithm() throws Exception { + MobileFlowFields testSubject; + Long samplingAlgorithm = null; + + // default test + testSubject = createTestSubject(); + testSubject.setSamplingAlgorithm(samplingAlgorithm); + } + + @Test + public void testGetTac() throws Exception { + MobileFlowFields testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getTac(); + } + + @Test + public void testSetTac() throws Exception { + MobileFlowFields testSubject; + String tac = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setTac(tac); + } + + @Test + public void testGetTunnelId() throws Exception { + MobileFlowFields testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getTunnelId(); + } + + @Test + public void testSetTunnelId() throws Exception { + MobileFlowFields testSubject; + String tunnelId = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setTunnelId(tunnelId); + } + + @Test + public void testGetVlanId() throws Exception { + MobileFlowFields testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getVlanId(); + } + + @Test + public void testSetVlanId() throws Exception { + MobileFlowFields testSubject; + String vlanId = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setVlanId(vlanId); + } + + @Test + public void testGetAdditionalProperties() throws Exception { + MobileFlowFields testSubject; + Map<String, Object> result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getAdditionalProperties(); + } + + @Test + public void testSetAdditionalProperty() throws Exception { + MobileFlowFields testSubject; + String name = ""; + Object value = null; + + // default test + testSubject = createTestSubject(); + testSubject.setAdditionalProperty(name, value); + } + + @Test + public void testToString() throws Exception { + MobileFlowFields testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.toString(); + } + + @Test + public void testHashCode() throws Exception { + MobileFlowFields testSubject; + int result; + + // default test + testSubject = createTestSubject(); + result = testSubject.hashCode(); + } + + @Test + public void testEquals() throws Exception { + MobileFlowFields testSubject; + Object other = null; + boolean result; + + // default test + testSubject = createTestSubject(); + result = testSubject.equals(other); + } +}
\ No newline at end of file diff --git a/UniversalVesAdapter/src/test/java/org/onap/dcaegen2/ves/domain/NameValuePairTest.java b/UniversalVesAdapter/src/test/java/org/onap/dcaegen2/ves/domain/NameValuePairTest.java new file mode 100644 index 0000000..f014279 --- /dev/null +++ b/UniversalVesAdapter/src/test/java/org/onap/dcaegen2/ves/domain/NameValuePairTest.java @@ -0,0 +1,123 @@ +/* +* ============LICENSE_START======================================================= +* ONAP : DCAE +* ================================================================================ +* Copyright 2018 TechMahindra +*================================================================================= +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +* ============LICENSE_END========================================================= +*/ +package org.onap.dcaegen2.ves.domain; + +import java.util.Map; + +import org.junit.Test; + +public class NameValuePairTest { + + private NameValuePair createTestSubject() { + return new NameValuePair(); + } + + @Test + public void testGetName() throws Exception { + NameValuePair testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getName(); + } + + @Test + public void testSetName() throws Exception { + NameValuePair testSubject; + String name = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setName(name); + } + + @Test + public void testGetValue() throws Exception { + NameValuePair testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getValue(); + } + + @Test + public void testSetValue() throws Exception { + NameValuePair testSubject; + String value = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setValue(value); + } + + @Test + public void testGetAdditionalProperties() throws Exception { + NameValuePair testSubject; + Map<String, Object> result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getAdditionalProperties(); + } + + @Test + public void testSetAdditionalProperty() throws Exception { + NameValuePair testSubject; + String name = ""; + Object value = null; + + // default test + testSubject = createTestSubject(); + testSubject.setAdditionalProperty(name, value); + } + + @Test + public void testToString() throws Exception { + NameValuePair testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.toString(); + } + + @Test + public void testHashCode() throws Exception { + NameValuePair testSubject; + int result; + + // default test + testSubject = createTestSubject(); + result = testSubject.hashCode(); + } + + @Test + public void testEquals() throws Exception { + NameValuePair testSubject; + Object other = null; + boolean result; + + // default test + testSubject = createTestSubject(); + result = testSubject.equals(other); + } +}
\ No newline at end of file diff --git a/UniversalVesAdapter/src/test/java/org/onap/dcaegen2/ves/domain/VNicPerformanceArrayTest.java b/UniversalVesAdapter/src/test/java/org/onap/dcaegen2/ves/domain/VNicPerformanceArrayTest.java new file mode 100644 index 0000000..6674244 --- /dev/null +++ b/UniversalVesAdapter/src/test/java/org/onap/dcaegen2/ves/domain/VNicPerformanceArrayTest.java @@ -0,0 +1,651 @@ +/* +* ============LICENSE_START======================================================= +* ONAP : DCAE +* ================================================================================ +* Copyright 2018 TechMahindra +*================================================================================= +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +* ============LICENSE_END========================================================= +*/ +package org.onap.dcaegen2.ves.domain; + +import java.util.Map; +import org.junit.Test; + +public class VNicPerformanceArrayTest { + + private VNicPerformanceArray createTestSubject() { + return new VNicPerformanceArray(); + } + + @Test + public void testGetValuesAreSuspect() throws Exception { + VNicPerformanceArray testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getValuesAreSuspect(); + } + + @Test + public void testSetValuesAreSuspect() throws Exception { + VNicPerformanceArray testSubject; + String valuesAreSuspect = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setValuesAreSuspect(valuesAreSuspect); + } + + @Test + public void testGetVNicIdentifier() throws Exception { + VNicPerformanceArray testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getVNicIdentifier(); + } + + @Test + public void testSetVNicIdentifier() throws Exception { + VNicPerformanceArray testSubject; + String vNicIdentifier = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setVNicIdentifier(vNicIdentifier); + } + + @Test + public void testGetReceivedBroadcastPacketsAccumulated() throws Exception { + VNicPerformanceArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getReceivedBroadcastPacketsAccumulated(); + } + + @Test + public void testSetReceivedBroadcastPacketsAccumulated() throws Exception { + VNicPerformanceArray testSubject; + Double receivedBroadcastPacketsAccumulated = null; + + // default test + testSubject = createTestSubject(); + testSubject.setReceivedBroadcastPacketsAccumulated(receivedBroadcastPacketsAccumulated); + } + + @Test + public void testGetReceivedBroadcastPacketsDelta() throws Exception { + VNicPerformanceArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getReceivedBroadcastPacketsDelta(); + } + + @Test + public void testSetReceivedBroadcastPacketsDelta() throws Exception { + VNicPerformanceArray testSubject; + Double receivedBroadcastPacketsDelta = null; + + // default test + testSubject = createTestSubject(); + testSubject.setReceivedBroadcastPacketsDelta(receivedBroadcastPacketsDelta); + } + + @Test + public void testGetReceivedDiscardedPacketsAccumulated() throws Exception { + VNicPerformanceArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getReceivedDiscardedPacketsAccumulated(); + } + + @Test + public void testSetReceivedDiscardedPacketsAccumulated() throws Exception { + VNicPerformanceArray testSubject; + Double receivedDiscardedPacketsAccumulated = null; + + // default test + testSubject = createTestSubject(); + testSubject.setReceivedDiscardedPacketsAccumulated(receivedDiscardedPacketsAccumulated); + } + + @Test + public void testGetReceivedDiscardedPacketsDelta() throws Exception { + VNicPerformanceArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getReceivedDiscardedPacketsDelta(); + } + + @Test + public void testSetReceivedDiscardedPacketsDelta() throws Exception { + VNicPerformanceArray testSubject; + Double receivedDiscardedPacketsDelta = null; + + // default test + testSubject = createTestSubject(); + testSubject.setReceivedDiscardedPacketsDelta(receivedDiscardedPacketsDelta); + } + + @Test + public void testGetReceivedErrorPacketsAccumulated() throws Exception { + VNicPerformanceArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getReceivedErrorPacketsAccumulated(); + } + + @Test + public void testSetReceivedErrorPacketsAccumulated() throws Exception { + VNicPerformanceArray testSubject; + Double receivedErrorPacketsAccumulated = null; + + // default test + testSubject = createTestSubject(); + testSubject.setReceivedErrorPacketsAccumulated(receivedErrorPacketsAccumulated); + } + + @Test + public void testGetReceivedErrorPacketsDelta() throws Exception { + VNicPerformanceArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getReceivedErrorPacketsDelta(); + } + + @Test + public void testSetReceivedErrorPacketsDelta() throws Exception { + VNicPerformanceArray testSubject; + Double receivedErrorPacketsDelta = null; + + // default test + testSubject = createTestSubject(); + testSubject.setReceivedErrorPacketsDelta(receivedErrorPacketsDelta); + } + + @Test + public void testGetReceivedMulticastPacketsAccumulated() throws Exception { + VNicPerformanceArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getReceivedMulticastPacketsAccumulated(); + } + + @Test + public void testSetReceivedMulticastPacketsAccumulated() throws Exception { + VNicPerformanceArray testSubject; + Double receivedMulticastPacketsAccumulated = null; + + // default test + testSubject = createTestSubject(); + testSubject.setReceivedMulticastPacketsAccumulated(receivedMulticastPacketsAccumulated); + } + + @Test + public void testGetReceivedMulticastPacketsDelta() throws Exception { + VNicPerformanceArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getReceivedMulticastPacketsDelta(); + } + + @Test + public void testSetReceivedMulticastPacketsDelta() throws Exception { + VNicPerformanceArray testSubject; + Double receivedMulticastPacketsDelta = null; + + // default test + testSubject = createTestSubject(); + testSubject.setReceivedMulticastPacketsDelta(receivedMulticastPacketsDelta); + } + + @Test + public void testGetReceivedOctetsAccumulated() throws Exception { + VNicPerformanceArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getReceivedOctetsAccumulated(); + } + + @Test + public void testSetReceivedOctetsAccumulated() throws Exception { + VNicPerformanceArray testSubject; + Double receivedOctetsAccumulated = null; + + // default test + testSubject = createTestSubject(); + testSubject.setReceivedOctetsAccumulated(receivedOctetsAccumulated); + } + + @Test + public void testGetReceivedOctetsDelta() throws Exception { + VNicPerformanceArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getReceivedOctetsDelta(); + } + + @Test + public void testSetReceivedOctetsDelta() throws Exception { + VNicPerformanceArray testSubject; + Double receivedOctetsDelta = null; + + // default test + testSubject = createTestSubject(); + testSubject.setReceivedOctetsDelta(receivedOctetsDelta); + } + + @Test + public void testGetReceivedTotalPacketsAccumulated() throws Exception { + VNicPerformanceArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getReceivedTotalPacketsAccumulated(); + } + + @Test + public void testSetReceivedTotalPacketsAccumulated() throws Exception { + VNicPerformanceArray testSubject; + Double receivedTotalPacketsAccumulated = null; + + // default test + testSubject = createTestSubject(); + testSubject.setReceivedTotalPacketsAccumulated(receivedTotalPacketsAccumulated); + } + + @Test + public void testGetReceivedTotalPacketsDelta() throws Exception { + VNicPerformanceArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getReceivedTotalPacketsDelta(); + } + + @Test + public void testSetReceivedTotalPacketsDelta() throws Exception { + VNicPerformanceArray testSubject; + Double receivedTotalPacketsDelta = null; + + // default test + testSubject = createTestSubject(); + testSubject.setReceivedTotalPacketsDelta(receivedTotalPacketsDelta); + } + + @Test + public void testGetReceivedUnicastPacketsAccumulated() throws Exception { + VNicPerformanceArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getReceivedUnicastPacketsAccumulated(); + } + + @Test + public void testSetReceivedUnicastPacketsAccumulated() throws Exception { + VNicPerformanceArray testSubject; + Double receivedUnicastPacketsAccumulated = null; + + // default test + testSubject = createTestSubject(); + testSubject.setReceivedUnicastPacketsAccumulated(receivedUnicastPacketsAccumulated); + } + + @Test + public void testGetReceivedUnicastPacketsDelta() throws Exception { + VNicPerformanceArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getReceivedUnicastPacketsDelta(); + } + + @Test + public void testSetReceivedUnicastPacketsDelta() throws Exception { + VNicPerformanceArray testSubject; + Double receivedUnicastPacketsDelta = null; + + // default test + testSubject = createTestSubject(); + testSubject.setReceivedUnicastPacketsDelta(receivedUnicastPacketsDelta); + } + + @Test + public void testGetTransmittedBroadcastPacketsAccumulated() throws Exception { + VNicPerformanceArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getTransmittedBroadcastPacketsAccumulated(); + } + + @Test + public void testSetTransmittedBroadcastPacketsAccumulated() throws Exception { + VNicPerformanceArray testSubject; + Double transmittedBroadcastPacketsAccumulated = null; + + // default test + testSubject = createTestSubject(); + testSubject.setTransmittedBroadcastPacketsAccumulated(transmittedBroadcastPacketsAccumulated); + } + + @Test + public void testGetTransmittedBroadcastPacketsDelta() throws Exception { + VNicPerformanceArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getTransmittedBroadcastPacketsDelta(); + } + + @Test + public void testSetTransmittedBroadcastPacketsDelta() throws Exception { + VNicPerformanceArray testSubject; + Double transmittedBroadcastPacketsDelta = null; + + // default test + testSubject = createTestSubject(); + testSubject.setTransmittedBroadcastPacketsDelta(transmittedBroadcastPacketsDelta); + } + + @Test + public void testGetTransmittedDiscardedPacketsAccumulated() throws Exception { + VNicPerformanceArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getTransmittedDiscardedPacketsAccumulated(); + } + + @Test + public void testSetTransmittedDiscardedPacketsAccumulated() throws Exception { + VNicPerformanceArray testSubject; + Double transmittedDiscardedPacketsAccumulated = null; + + // default test + testSubject = createTestSubject(); + testSubject.setTransmittedDiscardedPacketsAccumulated(transmittedDiscardedPacketsAccumulated); + } + + @Test + public void testGetTransmittedDiscardedPacketsDelta() throws Exception { + VNicPerformanceArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getTransmittedDiscardedPacketsDelta(); + } + + @Test + public void testSetTransmittedDiscardedPacketsDelta() throws Exception { + VNicPerformanceArray testSubject; + Double transmittedDiscardedPacketsDelta = null; + + // default test + testSubject = createTestSubject(); + testSubject.setTransmittedDiscardedPacketsDelta(transmittedDiscardedPacketsDelta); + } + + @Test + public void testGetTransmittedErrorPacketsAccumulated() throws Exception { + VNicPerformanceArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getTransmittedErrorPacketsAccumulated(); + } + + @Test + public void testSetTransmittedErrorPacketsAccumulated() throws Exception { + VNicPerformanceArray testSubject; + Double transmittedErrorPacketsAccumulated = null; + + // default test + testSubject = createTestSubject(); + testSubject.setTransmittedErrorPacketsAccumulated(transmittedErrorPacketsAccumulated); + } + + @Test + public void testGetTransmittedErrorPacketsDelta() throws Exception { + VNicPerformanceArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getTransmittedErrorPacketsDelta(); + } + + @Test + public void testSetTransmittedErrorPacketsDelta() throws Exception { + VNicPerformanceArray testSubject; + Double transmittedErrorPacketsDelta = null; + + // default test + testSubject = createTestSubject(); + testSubject.setTransmittedErrorPacketsDelta(transmittedErrorPacketsDelta); + } + + @Test + public void testGetTransmittedMulticastPacketsAccumulated() throws Exception { + VNicPerformanceArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getTransmittedMulticastPacketsAccumulated(); + } + + @Test + public void testSetTransmittedMulticastPacketsAccumulated() throws Exception { + VNicPerformanceArray testSubject; + Double transmittedMulticastPacketsAccumulated = null; + + // default test + testSubject = createTestSubject(); + testSubject.setTransmittedMulticastPacketsAccumulated(transmittedMulticastPacketsAccumulated); + } + + @Test + public void testGetTransmittedMulticastPacketsDelta() throws Exception { + VNicPerformanceArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getTransmittedMulticastPacketsDelta(); + } + + @Test + public void testSetTransmittedMulticastPacketsDelta() throws Exception { + VNicPerformanceArray testSubject; + Double transmittedMulticastPacketsDelta = null; + + // default test + testSubject = createTestSubject(); + testSubject.setTransmittedMulticastPacketsDelta(transmittedMulticastPacketsDelta); + } + + @Test + public void testGetTransmittedOctetsAccumulated() throws Exception { + VNicPerformanceArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getTransmittedOctetsAccumulated(); + } + + @Test + public void testSetTransmittedOctetsAccumulated() throws Exception { + VNicPerformanceArray testSubject; + Double transmittedOctetsAccumulated = null; + + // default test + testSubject = createTestSubject(); + testSubject.setTransmittedOctetsAccumulated(transmittedOctetsAccumulated); + } + + @Test + public void testGetTransmittedOctetsDelta() throws Exception { + VNicPerformanceArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getTransmittedOctetsDelta(); + } + + @Test + public void testSetTransmittedOctetsDelta() throws Exception { + VNicPerformanceArray testSubject; + Double transmittedOctetsDelta = null; + + // default test + testSubject = createTestSubject(); + testSubject.setTransmittedOctetsDelta(transmittedOctetsDelta); + } + + @Test + public void testGetTransmittedTotalPacketsAccumulated() throws Exception { + VNicPerformanceArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getTransmittedTotalPacketsAccumulated(); + } + + @Test + public void testSetTransmittedTotalPacketsAccumulated() throws Exception { + VNicPerformanceArray testSubject; + Double transmittedTotalPacketsAccumulated = null; + + // default test + testSubject = createTestSubject(); + testSubject.setTransmittedTotalPacketsAccumulated(transmittedTotalPacketsAccumulated); + } + + @Test + public void testGetTransmittedTotalPacketsDelta() throws Exception { + VNicPerformanceArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getTransmittedTotalPacketsDelta(); + } + + @Test + public void testSetTransmittedTotalPacketsDelta() throws Exception { + VNicPerformanceArray testSubject; + Double transmittedTotalPacketsDelta = null; + + // default test + testSubject = createTestSubject(); + testSubject.setTransmittedTotalPacketsDelta(transmittedTotalPacketsDelta); + } + + @Test + public void testGetTransmittedUnicastPacketsAccumulated() throws Exception { + VNicPerformanceArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getTransmittedUnicastPacketsAccumulated(); + } + + @Test + public void testSetTransmittedUnicastPacketsAccumulated() throws Exception { + VNicPerformanceArray testSubject; + Double transmittedUnicastPacketsAccumulated = null; + + // default test + testSubject = createTestSubject(); + testSubject.setTransmittedUnicastPacketsAccumulated(transmittedUnicastPacketsAccumulated); + } + + @Test + public void testGetTransmittedUnicastPacketsDelta() throws Exception { + VNicPerformanceArray testSubject; + Double result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getTransmittedUnicastPacketsDelta(); + } + + @Test + public void testSetTransmittedUnicastPacketsDelta() throws Exception { + VNicPerformanceArray testSubject; + Double transmittedUnicastPacketsDelta = null; + + // default test + testSubject = createTestSubject(); + testSubject.setTransmittedUnicastPacketsDelta(transmittedUnicastPacketsDelta); + } + + @Test + public void testGetAdditionalProperties() throws Exception { + VNicPerformanceArray testSubject; + Map<String, Object> result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getAdditionalProperties(); + } + + @Test + public void testSetAdditionalProperty() throws Exception { + VNicPerformanceArray testSubject; + String name = ""; + Object value = null; + + // default test + testSubject = createTestSubject(); + testSubject.setAdditionalProperty(name, value); + } +}
\ No newline at end of file |