*/
package org.opendaylight.transportpce.pce;
-import org.junit.Assert;
-import org.junit.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+import org.junit.jupiter.api.Test;
public class PceComplianceCheckResultTest {
PceComplianceCheckResult pceComplianceCheckResult = new PceComplianceCheckResult(false, "message");
@Test
- public void checkGetter() {
- Assert.assertEquals(false, pceComplianceCheckResult.hasPassed());
- Assert.assertNotNull(pceComplianceCheckResult.getMessage());
+ void checkGetter() {
+ assertEquals(false, pceComplianceCheckResult.hasPassed());
+ assertNotNull(pceComplianceCheckResult.getMessage());
}
}
package org.opendaylight.transportpce.pce;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Test;
import org.opendaylight.transportpce.pce.utils.PceTestData;
import org.opendaylight.transportpce.test.AbstractTest;
public class PceComplianceCheckTest extends AbstractTest {
-
- @Before
- public void setup() {
-
- }
-
@Test
- public void testCheckFalse() {
- Assert.assertFalse(
- PceComplianceCheck.check(PceTestData.getEmptyPCERequest()).hasPassed());
+ void testCheckFalse() {
+ assertFalse(PceComplianceCheck.check(PceTestData.getEmptyPCERequest()).hasPassed());
}
@Test
- public void testCheckTrue() {
- Assert.assertTrue(
- PceComplianceCheck.check(PceTestData.getEmptyPCERequestServiceNameWithRequestId()).hasPassed());
+ void testCheckTrue() {
+ assertTrue(PceComplianceCheck.check(PceTestData.getEmptyPCERequestServiceNameWithRequestId()).hasPassed());
}
@Test
- public void testCheckFalseWihtoutRequestID() {
- Assert.assertFalse(
- PceComplianceCheck.check(PceTestData.getEmptyPCERequestServiceNameWithOutRequestId()).hasPassed());
+ void testCheckFalseWihtoutRequestID() {
+ assertFalse(PceComplianceCheck.check(PceTestData.getEmptyPCERequestServiceNameWithOutRequestId()).hasPassed());
}
}
package org.opendaylight.transportpce.pce;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.math.BigDecimal;
import java.util.List;
import java.util.Map;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.opendaylight.transportpce.common.StringConstants;
@Mock
private PortMapping portMapping;
- @Before
+ @BeforeEach
public void setUp() {
MockitoAnnotations.openMocks(this);
// Build Link
- link = NodeUtils.createRoadmToRoadm("OpenROADM-3-2-DEG1",
- "OpenROADM-3-1-DEG1",
- "DEG1-TTP-TX", "DEG1-TTP-RX").build();
+ link = NodeUtils
+ .createRoadmToRoadm("OpenROADM-3-2-DEG1", "OpenROADM-3-1-DEG1", "DEG1-TTP-TX", "DEG1-TTP-RX")
+ .build();
// Link link=genereateLinkBuilder();
pceResult.setRC("200");
pceResult.setRate(Long.valueOf(1));
pceResult.setServiceType(StringConstants.SERVICE_TYPE_100GE_T);
- Map<LinkId, PceLink> map = Map.of(new LinkId("OpenROADM-3-1-DEG1-to-OpenROADM-3-2-DEG1"), pceLink);
- pcePathDescription = new PcePathDescription(List.of(pceLink),
- map, pceResult);
+ pceResult.setMaxFreq(new BigDecimal("195.900"));
+ pceResult.setMinFreq(new BigDecimal("191.101"));
+ Map<LinkId, PceLink> map = Map.of(
+ new LinkId("OpenROADM-3-2-DEG1-DEG1-TTP-TXtoOpenROADM-3-1-DEG1-DEG1-TTP-RX"), pceLink,
+ new LinkId("OpenROADM-3-1-DEG1-DEG1-TTP-RXtoOpenROADM-3-2-DEG1-DEG1-TTP-TX"), pceLink);
+ pcePathDescription = new PcePathDescription(List.of(pceLink), map, pceResult);
}
- // TODO fix opposite link
- @Test(expected = Exception.class)
- public void buildDescriptionsTest() {
-
+ @Test
+ void buildDescriptionsTest() {
pcePathDescription.buildDescriptions();
- Assert.assertEquals(pcePathDescription.getReturnStructure().getMessage(), "No path available by PCE");
+ assertEquals(pcePathDescription.getReturnStructure().getMessage(), "Path is calculated by PCE");
}
@Test
- public void mapUtil() {
+ void mapUtil() {
PceConstraints pceConstraintsCalc = new PceConstraintsCalc(
- PceTestData.getPCERequest(),
- new NetworkTransactionImpl(getDataBroker()))
- .getPceHardConstraints();
+ PceTestData.getPCERequest(), new NetworkTransactionImpl(getDataBroker())).getPceHardConstraints();
MapUtils.mapDiversityConstraints(List.of(node), List.of(link), pceConstraintsCalc);
MapUtils.getSupLink(link);
MapUtils.getAllSupNode(node);
MapUtils.getSRLGfromLink(link);
}
-
}
package org.opendaylight.transportpce.pce;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.when;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.jupiter.MockitoExtension;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.dom.codec.spi.BindingDOMCodecServices;
import org.opendaylight.transportpce.common.mapping.PortMapping;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev220316.network.nodes.NodeInfoBuilder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.types.rev191129.NodeTypes;
-@RunWith(MockitoJUnitRunner.class)
+@ExtendWith(MockitoExtension.class)
public class PceSendingPceRPCsTest extends AbstractTest {
private PceSendingPceRPCs pceSendingPceRPCs;
private PortMapping portMapping;
- @Before
- public void setUp() {
+ @BeforeEach
+ void setUp() {
this.dataBroker = getNewDataBroker();
networkTransaction = new NetworkTransactionImpl(this.dataBroker);
PceTestUtils.writeNetworkInDataStore(this.dataBroker);
- gnpyConsumer = new GnpyConsumerImpl("http://localhost:9998",
- "mylogin", "mypassword", getDataStoreContextUtil().getBindingDOMCodecServices());
- pceSendingPceRPCs = new PceSendingPceRPCs(PceTestData.getPCE_test1_request_54(),
- networkTransaction, gnpyConsumer, portMapping);
- mapping = new MappingBuilder().setLogicalConnectionPoint("logicalConnectionPoint").setPortQual("xpdr-client")
+ gnpyConsumer = new GnpyConsumerImpl(
+ "http://localhost:9998", "mylogin", "mypassword", getDataStoreContextUtil().getBindingDOMCodecServices());
+ pceSendingPceRPCs = new PceSendingPceRPCs(
+ PceTestData.getPCE_test1_request_54(), networkTransaction, gnpyConsumer, portMapping);
+ mapping = new MappingBuilder()
+ .setLogicalConnectionPoint("logicalConnectionPoint")
+ .setPortQual("xpdr-client")
.build();
NodeInfo info = new NodeInfoBuilder().setNodeType(NodeTypes.Xpdr).build();
Nodes node = new NodesBuilder().withKey(new NodesKey("node")).setNodeId("node").setNodeInfo(info).build();
- when(portMapping.getMapping(anyString(), anyString())).thenReturn(mapping);
- when(portMapping.getNode(anyString())).thenReturn(node);
+ lenient().when(portMapping.getMapping(anyString(), anyString())).thenReturn(mapping);
+ lenient().when(portMapping.getNode(anyString())).thenReturn(node);
}
@Test
- public void cancelResourceReserve() {
+ void cancelResourceReserve() {
pceSendingPceRPCs.cancelResourceReserve();
- Assert.assertTrue("Success should equal to true", pceSendingPceRPCs.getSuccess());
+ assertTrue(pceSendingPceRPCs.getSuccess(), "Success should equal to true");
}
@Test
- public void pathComputationTest() throws Exception {
+ void pathComputationTest() throws Exception {
jerseyServer.setUp();
- pceSendingPceRPCs =
- new PceSendingPceRPCs(PceTestData.getGnpyPCERequest("XPONDER-1", "XPONDER-2"),
- networkTransaction, gnpyConsumer, portMapping);
+ pceSendingPceRPCs = new PceSendingPceRPCs(PceTestData.getGnpyPCERequest("XPONDER-1", "XPONDER-2"),
+ networkTransaction, gnpyConsumer, portMapping);
when(portMapping.getMapping(anyString(), anyString())).thenReturn(mapping);
pceSendingPceRPCs.pathComputation();
- Assert.assertTrue(gnpyConsumer.isAvailable());
+ assertTrue(gnpyConsumer.isAvailable());
jerseyServer.tearDown();
-
}
@Test
- public void checkMessage() {
- Assert.assertNull(pceSendingPceRPCs.getMessage());
+ void checkMessage() {
+ assertNull(pceSendingPceRPCs.getMessage());
}
@Test
- public void responseCodeTest() {
- Assert.assertNull(pceSendingPceRPCs.getResponseCode());
+ void responseCodeTest() {
+ assertNull(pceSendingPceRPCs.getResponseCode());
}
@Test
- public void gnpyAtoZ() {
- Assert.assertNull(pceSendingPceRPCs.getGnpyAtoZ());
+ void gnpyAtoZ() {
+ assertNull(pceSendingPceRPCs.getGnpyAtoZ());
}
@Test
- public void getGnpyZtoA() {
- Assert.assertNull(pceSendingPceRPCs.getGnpyZtoA());
+ void getGnpyZtoA() {
+ assertNull(pceSendingPceRPCs.getGnpyZtoA());
}
-
-
}
*/
package org.opendaylight.transportpce.pce;
-import org.junit.Assert;
-import org.junit.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
public class SortPortsByNameTest {
private SortPortsByName sortPortsByName = new SortPortsByName();
@Test
- public void compareTest() {
- Assert.assertEquals(12, sortPortsByName.compare("value22", "valu10"));
+ void compareTest() {
+ assertEquals(12, sortPortsByName.compare("value22", "valu10"));
}
@Test
- public void compareWithoutNUM() {
- Assert.assertEquals(0, sortPortsByName.compare("value", "value"));
+ void compareWithoutNUM() {
+ assertEquals(0, sortPortsByName.compare("value", "value"));
}
@Test
- public void compareLessThan() {
- Assert.assertEquals(-11, sortPortsByName.compare("value1", "value12"));
+ void compareLessThan() {
+ assertEquals(-11, sortPortsByName.compare("value1", "value12"));
}
-
-
-}
+}
\ No newline at end of file
package org.opendaylight.transportpce.pce.constraints;
-import org.junit.Before;
-import org.junit.Test;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.NoSuchElementException;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.transportpce.common.network.NetworkTransactionImpl;
import org.opendaylight.transportpce.common.network.NetworkTransactionService;
private DataBroker dataBroker = getDataBroker();
//TODO: review this test class. May be miss few assert.
- @Before
- public void setup() throws Exception {
+ @BeforeEach
+ void setup() throws Exception {
// networkTransactionService = Mockito.mock(NetworkTransactionService.class);
PceTestUtils.writeNetworkIntoDataStore(dataBroker, getDataStoreContextUtil(),
TransactionUtils.getNetworkForSpanLoss());
}
@Test
- public void testNoHardOrSoftConstrainsExists() {
+ void testNoHardOrSoftConstrainsExists() {
PceTestData.getPCE_test2_request_54().getSoftConstraints();
new PceConstraintsCalc(PceTestData.getEmptyPCERequest(), networkTransactionService);
}
@Test()
- public void testHardConstrainsExists() {
+ void testHardConstrainsExists() {
new PceConstraintsCalc(
PceTestData.getPCE_simpletopology_test1_requestSetHardAndSoftConstrains(),
networkTransactionService);
}
@Test()
- public void testHardConstrainsExists1() {
+ void testHardConstrainsExists1() {
new PceConstraintsCalc(
PceTestData.getPathComputationRequestInputWithCoRoutingOrGeneral(),
networkTransactionService);
}
@Test
- public void testSoftConstrainsExists() {
+ void testSoftConstrainsExists() {
new PceConstraintsCalc(PceTestData.getPCERequest(), networkTransactionService);
}
- @Test(expected = Exception.class)
- public void testHardConstrainsExists2() {
- new PceConstraintsCalc(
- PceTestData.build_diversity_from_request(PceTestData.getPCERequest()),
- networkTransactionService);
+ //TODO: See if this test is relevant.
+ @Test
+ void testHardConstrainsExists2() {
+ Exception exception = assertThrows(NoSuchElementException.class, () -> {
+ new PceConstraintsCalc(
+ PceTestData.build_diversity_from_request(PceTestData.getPCERequest()),
+ networkTransactionService);
+ });
+ assertTrue(exception.getMessage().contains("No value present"));
}
@Test()
- public void testHardConstrainsExists3() {
+ void testHardConstrainsExists3() {
new PceConstraintsCalc(PceTestData.getEmptyPCERequestServiceNameWithRequestId(), networkTransactionService);
}
@Test()
- public void testHardConstrainsExists4() {
+ void testHardConstrainsExists4() {
new PceConstraintsCalc(PceTestData.getPCE_test2_request_54(), networkTransactionService);
}
-
}
package org.opendaylight.transportpce.pce.constraints;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
import java.util.ArrayList;
import java.util.List;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.opendaylight.transportpce.pce.networkanalyzer.PceOpticalNode;
import org.opendaylight.transportpce.test.AbstractTest;
public class PceConstraintsTest extends AbstractTest {
private static PceConstraints pceConstraints = new PceConstraints();
- @Before
- public void setup() {
+ @BeforeEach
+ void setup() {
pceConstraints = new PceConstraints();
}
@Test
- public void setAndGetMaxLatencyTest() {
- Assert.assertEquals(-1, pceConstraints.getMaxLatency().intValue());
+ void setAndGetMaxLatencyTest() {
+ assertEquals(-1, pceConstraints.getMaxLatency().intValue());
pceConstraints.setMaxLatency(-2L);
- Assert.assertEquals(-2, pceConstraints.getMaxLatency().intValue());
+ assertEquals(-2, pceConstraints.getMaxLatency().intValue());
}
@Test
- public void setAndGetExcludeSupNodesTest() {
- Assert.assertEquals(0, pceConstraints.getExcludeSupNodes().size());
+ void setAndGetExcludeSupNodesTest() {
+ assertEquals(0, pceConstraints.getExcludeSupNodes().size());
List<String> nodes = new ArrayList<>();
nodes.add("test");
pceConstraints.setExcludeSupNodes(nodes);
- Assert.assertEquals(1, pceConstraints.getExcludeSupNodes().size());
+ assertEquals(1, pceConstraints.getExcludeSupNodes().size());
}
@Test
- public void setAndGetExcludeSRLGTest() {
- Assert.assertEquals(0, pceConstraints.getExcludeSRLG().size());
+ void setAndGetExcludeSRLGTest() {
+ assertEquals(0, pceConstraints.getExcludeSRLG().size());
List<Long> nodes = new ArrayList<>();
nodes.add(1L);
pceConstraints.setExcludeSRLG(nodes);
- Assert.assertEquals(1, pceConstraints.getExcludeSRLG().size());
+ assertEquals(1, pceConstraints.getExcludeSRLG().size());
}
@Test
- public void setAndGetExcludeCLLITest() {
- Assert.assertEquals(0, pceConstraints.getExcludeCLLI().size());
+ void setAndGetExcludeCLLITest() {
+ assertEquals(0, pceConstraints.getExcludeCLLI().size());
List<String> nodes = new ArrayList<>();
nodes.add("test");
pceConstraints.setExcludeCLLI(nodes);
- Assert.assertEquals(1, pceConstraints.getExcludeCLLI().size());
+ assertEquals(1, pceConstraints.getExcludeCLLI().size());
}
@Test
- public void setAndGetExcludeClliNodesTest() {
- Assert.assertEquals(0, pceConstraints.getExcludeClliNodes().size());
+ void setAndGetExcludeClliNodesTest() {
+ assertEquals(0, pceConstraints.getExcludeClliNodes().size());
List<String> nodes = new ArrayList<>();
nodes.add("test");
pceConstraints.setExcludeClliNodes(nodes);
- Assert.assertEquals(1, pceConstraints.getExcludeClliNodes().size());
+ assertEquals(1, pceConstraints.getExcludeClliNodes().size());
}
@Test
- public void setAndGetExcludeSrlgLinksTest() {
- Assert.assertEquals(0, pceConstraints.getExcludeSrlgLinks().size());
+ void setAndGetExcludeSrlgLinksTest() {
+ assertEquals(0, pceConstraints.getExcludeSrlgLinks().size());
List<String> nodes = new ArrayList<>();
nodes.add("test");
pceConstraints.setExcludeSrlgLinks(nodes);
- Assert.assertEquals(1, pceConstraints.getExcludeSrlgLinks().size());
+ assertEquals(1, pceConstraints.getExcludeSrlgLinks().size());
}
@Test
- public void setAndGetExcludeNodesTest() {
- Assert.assertEquals(0, pceConstraints.getExcludeNodes().size());
+ void setAndGetExcludeNodesTest() {
+ assertEquals(0, pceConstraints.getExcludeNodes().size());
List<String> nodes = new ArrayList<>();
nodes.add("test");
pceConstraints.setExcludeNodes(nodes);
- Assert.assertEquals(1, pceConstraints.getExcludeNodes().size());
+ assertEquals(1, pceConstraints.getExcludeNodes().size());
}
@Test
- public void setAndGetIncludeNodesTest() {
- Assert.assertEquals(0, pceConstraints.getIncludeNodes().size());
+ void setAndGetIncludeNodesTest() {
+ assertEquals(0, pceConstraints.getIncludeNodes().size());
List<String> nodes = new ArrayList<>();
nodes.add("test");
pceConstraints.setIncludeNodes(nodes);
- Assert.assertEquals(1, pceConstraints.getIncludeNodes().size());
+ assertEquals(1, pceConstraints.getIncludeNodes().size());
}
@Test
- public void getTypeAndNameOfResourcePairTest() {
+ void getTypeAndNameOfResourcePairTest() {
PceConstraints.ResourcePair resourcePair = new PceConstraints
.ResourcePair(PceConstraints.ResourceType.CLLI, "test");
- Assert.assertEquals(resourcePair.getType(), PceConstraints.ResourceType.CLLI);
- Assert.assertEquals("test", resourcePair.getName());
-
+ assertEquals(resourcePair.getType(), PceConstraints.ResourceType.CLLI);
+ assertEquals("test", resourcePair.getName());
}
@Test
- public void getIncludePceNodesTest() {
- Assert.assertTrue(pceConstraints.getIncludePceNodes().size() == 0);
+ void getIncludePceNodesTest() {
+ assertTrue(pceConstraints.getIncludePceNodes().size() == 0);
pceConstraints.setIncludePceNode(new PceOpticalNode(null, null, null, null, null, null, null, null));
- Assert.assertTrue(pceConstraints.getIncludePceNodes().size() == 1);
-
+ assertTrue(pceConstraints.getIncludePceNodes().size() == 1);
}
@Test
- public void getListToIncludeTest() {
- Assert.assertTrue(pceConstraints.getListToInclude().size() == 0);
+ void getListToIncludeTest() {
+ assertTrue(pceConstraints.getListToInclude().size() == 0);
PceConstraints.ResourcePair resourcePair = new PceConstraints
.ResourcePair(PceConstraints.ResourceType.SRLG, "test");
pceConstraints.setListToInclude(resourcePair);
- Assert.assertTrue(pceConstraints.getListToInclude().size() == 1);
- Assert.assertTrue(pceConstraints.getSRLGnames().size() == 1);
-
+ assertTrue(pceConstraints.getListToInclude().size() == 1);
+ assertTrue(pceConstraints.getSRLGnames().size() == 1);
}
-
}
-
-
*/
package org.opendaylight.transportpce.pce.gnpy;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.fail;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.fail;
import com.google.gson.stream.JsonReader;
import java.io.FileNotFoundException;
import org.glassfish.grizzly.http.server.HttpServer;
import org.glassfish.jersey.grizzly2.httpserver.GrizzlyHttpServerFactory;
import org.glassfish.jersey.server.ResourceConfig;
-import org.junit.AfterClass;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.NetworkUtils;
import org.opendaylight.transportpce.common.network.NetworkTransactionImpl;
}
- @Before
- public void initConsumer() {
+ @BeforeEach
+ void initConsumer() {
gnpyConsumer = new GnpyConsumerImpl("http://localhost:9998", "mylogin", "mypassword",
getDataStoreContextUtil().getBindingDOMCodecServices());
}
- @BeforeClass
- public static void init() {
+ @BeforeAll
+ static void init() {
// here we cannot use JerseyTest as we already extends AbstractTest
final ResourceConfig rc = new ResourceConfig(GnpyStub.class);
httpServer = GrizzlyHttpServerFactory.createHttpServer(URI.create("http://localhost:9998"), rc);
}
- @AfterClass
- public static void tearDown() {
+ @AfterAll
+ static void tearDown() {
httpServer.shutdownNow();
}
}
@Test
- public void askNewPathFromGnpyNullResultTest() throws Exception {
+ void askNewPathFromGnpyNullResultTest() throws Exception {
gnpyUtilitiesImpl = new GnpyUtilitiesImpl(networkTransaction,
PceTestData.getGnpyPCERequest("XPONDER-1", "XPONDER-2"),
gnpyConsumer);
- assertNull("No hard constraints should be available", gnpyUtilitiesImpl.askNewPathFromGnpy(null));
-
+ assertNull(gnpyUtilitiesImpl.askNewPathFromGnpy(null), "No hard constraints should be available");
}
@Test
- public void askNewPathFromGnpyTest() throws Exception {
+ void askNewPathFromGnpyTest() throws Exception {
gnpyUtilitiesImpl = new GnpyUtilitiesImpl(networkTransaction,
PceTestData.getGnpyPCERequest("XPONDER-3", "XPONDER-4"),
gnpyConsumer);
PceConstraintsCalc constraints = new PceConstraintsCalc(PceTestData.getPCE_simpletopology_test1_request(),
networkTransaction);
PceConstraints pceHardConstraints = constraints.getPceHardConstraints();
- assertNotNull("Hard constraints should be available", gnpyUtilitiesImpl.askNewPathFromGnpy(pceHardConstraints));
-
-
+ assertNotNull(gnpyUtilitiesImpl.askNewPathFromGnpy(pceHardConstraints), "Hard constraints should be available");
}
@Test
- public void verifyComputationByGnpyTest() throws Exception {
+ void verifyComputationByGnpyTest() throws Exception {
// build AtoZ
AToZDirectionBuilder atoZDirectionBldr = buildAtZ();
// build ZtoA
boolean result = gnpyUtilitiesImpl.verifyComputationByGnpy(atoZDirectionBldr.build(),
ztoADirectionBldr.build(),
pceHardConstraints);
- Assert.assertFalse("Gnpy Computation should be false",result);
+ assertFalse(result, "Gnpy Computation should be false");
}
private AToZDirectionBuilder buildAtZ() {
.build();
Resource clientResource = new ResourceBuilder().setResource(stp).build();
AToZ firstResource = new AToZBuilder().setId("tpName").withKey(clientKey).setResource(clientResource).build();
-
return new AToZDirectionBuilder()
.setRate(Uint32.valueOf(100))
.setAToZ(Map.of(firstResource.key(),firstResource))
.setAToZWavelengthNumber(Uint32.valueOf(0));
-
}
private ZToADirectionBuilder buildZtoA() {
.setRate(Uint32.valueOf(100))
.setZToA(Map.of(firstResource.key(),firstResource))
.setZToAWavelengthNumber(Uint32.valueOf(0));
-
}
}
*/
package org.opendaylight.transportpce.pce.gnpy.consumer;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.IOException;
import java.nio.file.Files;
import javax.ws.rs.core.Application;
import org.glassfish.jersey.server.ResourceConfig;
import org.glassfish.jersey.test.JerseyTest;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
import org.opendaylight.transportpce.common.converter.JsonStringConverter;
import org.opendaylight.transportpce.test.AbstractTest;
import org.opendaylight.yang.gen.v1.gnpy.gnpy.api.rev220221.Request;
}
@Test
- public void isAvailableTest() {
+ void isAvailableTest() {
GnpyConsumer gnpyConsumer = new GnpyConsumerImpl("http://localhost:9998",
"mylogin",
"mypassword",
AbstractTest.getDataStoreContextUtil().getBindingDOMCodecServices());
- assertTrue("Gnpy should be available", gnpyConsumer.isAvailable());
+ assertTrue(gnpyConsumer.isAvailable(), "Gnpy should be available");
}
@Test
- public void computePathsTest() throws IOException {
+ void computePathsTest() throws IOException {
GnpyConsumer gnpyConsumer = new GnpyConsumerImpl("http://localhost:9998",
"mylogin",
"mypassword",
JSONCodecFactorySupplier.DRAFT_LHOTKA_NETMOD_YANG_JSON_02);
Result result = gnpyConsumer.computePaths(request);
LOG.info("Response received {}", result);
- assertNotNull("Result should not be null", result);
+ assertNotNull(result, "Result should not be null");
}
}
package org.opendaylight.transportpce.pce.graph;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.opendaylight.transportpce.common.StringConstants;
private PortMapping portMapping;
- @Before
- public void setUp() {
+ @BeforeEach
+ void setUp() {
MockitoAnnotations.openMocks(this);
// Build Link
- link = NodeUtils.createRoadmToRoadm("OpenROADM-3-2-DEG1",
- "OpenROADM-3-1-DEG1",
- "DEG1-TTP-TX", "DEG1-TTP-RX").build();
-
- // Link link=genereateLinkBuilder();
+ link = NodeUtils.createRoadmToRoadm("OpenROADM-3-2-DEG1", "OpenROADM-3-1-DEG1", "DEG1-TTP-TX", "DEG1-TTP-RX")
+ .build();
node = NodeUtils.getNodeBuilder(NodeUtils.geSupportingNodes()).build();
-
PceOpticalNode pceOpticalNode = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node,
OpenroadmNodeType.SRG, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50);
PceOpticalNode pceOpticalNode2 = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node,
OpenroadmNodeType.SRG, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50);
-
pceLink = new PceLink(link, pceOpticalNode, pceOpticalNode2);
pceLink.setClient("XPONDER-CLIENT");
}
@Test
- public void getLink() {
- Assert.assertEquals(pceGraphEdge.link().getLinkId(),
- pceLink.getLinkId());
+ void getLink() {
+ assertEquals(pceGraphEdge.link().getLinkId(), pceLink.getLinkId());
}
}
package org.opendaylight.transportpce.pce.graph;
-import static org.junit.Assert.fail;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.fail;
import com.google.common.collect.ImmutableMap;
import com.google.gson.stream.JsonReader;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import org.eclipse.jdt.annotation.NonNull;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.mockito.MockitoAnnotations;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.MountPoint;
import org.opendaylight.transportpce.pce.networkanalyzer.PceCalculation;
import org.opendaylight.transportpce.pce.networkanalyzer.PceLink;
import org.opendaylight.transportpce.pce.networkanalyzer.PceNode;
-//import org.opendaylight.transportpce.pce.networkanalyzer.PceOpticalNode;
import org.opendaylight.transportpce.pce.networkanalyzer.PceOtnNode;
import org.opendaylight.transportpce.pce.networkanalyzer.PceResult;
import org.opendaylight.transportpce.pce.utils.JsonUtil;
// Test of integration for PceGraph
- @Before
- public void setUp() throws InterruptedException, ExecutionException {
+ @BeforeEach
+ void setUp() throws InterruptedException, ExecutionException {
// PortMapping is instantiated to create the mapping of the different nodes in the topology
this.dataBroker = getNewDataBroker();
this.mountPoint = new MountPointStub(dataBroker);
pceHardConstraints = new PceConstraints();
this.rc = new PceResult();
this.netTransServ = new NetworkTransactionImpl(dataBroker);
-
LOG.info("The value of the mapping is {}", portMapping);
-
}
// TOPOLOGY ON WHICH TEST ARE BASED
// |_____| |_____|
//
@Test
- public void clacPath100GE() {
+ void clacPath100GE() {
PceCalculation pceCalc = new PceCalculation(getPCE1Request(Uint32.valueOf(100), ServiceFormat.Ethernet,
"XPONDER-1", "Node1", "Client-1", "XPONDER-3", "Node3", "Client-1"),
netTransServ, pceHardConstraints, null, rc, portMapping);
pceGraph = new PceGraph(pceCalc.getaendPceNode(), pceCalc.getzendPceNode(),
pceCalc.getAllPceNodes(), pceCalc.getAllPceLinks(), pceHardConstraints,
null, rc, StringConstants.SERVICE_TYPE_100GE_T, netTransServ);
- Assert.assertEquals(pceGraph.calcPath(), true);
- Assert.assertEquals(Optional.ofNullable(pceGraph.getmargin()),
- Optional.ofNullable(3.0919881995992924));
+ assertEquals(pceGraph.calcPath(), true);
+ assertEquals(Optional.ofNullable(pceGraph.getmargin()), Optional.ofNullable(3.0919881995992924));
}
@Test
- public void clacPathOTUC2() {
+ void clacPathOTUC2() {
PceCalculation pceCalc = new PceCalculation(getPCE1Request(Uint32.valueOf(200), ServiceFormat.Ethernet,
"XPONDER-1", "Node1", "XPDR-NW1-TX", "XPONDER-4", "Node4", "XPDR-NW1-RX"),
netTransServ, pceHardConstraints, null, rc, portMapping);
pceGraph = new PceGraph(pceCalc.getaendPceNode(), pceCalc.getzendPceNode(),
pceCalc.getAllPceNodes(), pceCalc.getAllPceLinks(), pceHardConstraints,
null, rc, StringConstants.SERVICE_TYPE_OTUC2, netTransServ);
- Assert.assertEquals(pceGraph.calcPath(), true);
- Assert.assertEquals(Optional.ofNullable(pceGraph.getmargin()),
- Optional.ofNullable(1.1559963686478447));
+ assertEquals(pceGraph.calcPath(), true);
+ assertEquals(Optional.ofNullable(pceGraph.getmargin()), Optional.ofNullable(1.1559963686478447));
}
@Test
- public void clacPathOTUC3() {
+ void clacPathOTUC3() {
PceCalculation pceCalc = new PceCalculation(getPCE1Request(Uint32.valueOf(300), ServiceFormat.Ethernet,
"XPONDER-1", "Node1", "XPDR-NW1-TX", "XPONDER-3", "Node3", "XPDR-NW1-RX"),
netTransServ, pceHardConstraints, null, rc, portMapping);
pceGraph = new PceGraph(pceCalc.getaendPceNode(), pceCalc.getzendPceNode(),
pceCalc.getAllPceNodes(), pceCalc.getAllPceLinks(), pceHardConstraints,
null, rc, StringConstants.SERVICE_TYPE_OTUC3, netTransServ);
- Assert.assertEquals(pceGraph.calcPath(), true);
- Assert.assertEquals(Optional.ofNullable(pceGraph.getmargin()),
- Optional.ofNullable(0.3351048800367167));
+ assertEquals(pceGraph.calcPath(), true);
+ assertEquals(Optional.ofNullable(pceGraph.getmargin()), Optional.ofNullable(0.3351048800367167));
}
@Test
- public void clacUnfeasiblePath400GE() {
+ void clacUnfeasiblePath400GE() {
PceCalculation pceCalc = new PceCalculation(getPCE1Request(Uint32.valueOf(400), ServiceFormat.Ethernet,
"XPONDER-1", "Node1", "Client-1", "XPONDER-3", "Node3", "Client-1"),
netTransServ, pceHardConstraints, null, rc, portMapping);
pceGraph = new PceGraph(pceCalc.getaendPceNode(), pceCalc.getzendPceNode(),
pceCalc.getAllPceNodes(), pceCalc.getAllPceLinks(), pceHardConstraints,
null, rc, StringConstants.SERVICE_TYPE_400GE, netTransServ);
- Assert.assertEquals(pceGraph.calcPath(), false);
- Assert.assertEquals(Optional.ofNullable(pceGraph.getmargin()),
- Optional.ofNullable(0.0));
+ assertEquals(pceGraph.calcPath(), false);
+ assertEquals(Optional.ofNullable(pceGraph.getmargin()), Optional.ofNullable(0.0));
}
@Test
- public void clacPath400GE() {
+ void clacPath400GE() {
PceCalculation pceCalc = new PceCalculation(getPCE1Request(Uint32.valueOf(400), ServiceFormat.Ethernet,
"XPONDER-1", "Node1", "Client-1", "XPONDER-5", "Node5", "Client-1"),
netTransServ, pceHardConstraints, null, rc, portMapping);
pceGraph = new PceGraph(pceCalc.getaendPceNode(), pceCalc.getzendPceNode(),
pceCalc.getAllPceNodes(), pceCalc.getAllPceLinks(), pceHardConstraints,
null, rc, StringConstants.SERVICE_TYPE_400GE, netTransServ);
- Assert.assertEquals(pceGraph.calcPath(), true);
- Assert.assertEquals(Optional.ofNullable(pceGraph.getmargin()),
- Optional.ofNullable(1.4432381874659086));
+ assertEquals(pceGraph.calcPath(), true);
+ assertEquals(Optional.ofNullable(pceGraph.getmargin()), Optional.ofNullable(1.4432381874659086));
}
@Test
- public void clacPathOTUC4() {
+ void clacPathOTUC4() {
PceCalculation pceCalc = new PceCalculation(getPCE1Request(Uint32.valueOf(400), ServiceFormat.Ethernet,
"XPONDER-1", "Node1", "XPDR-NW1-TX", "XPONDER-5", "Node5", "XPDR-NW1-RX"),
netTransServ, pceHardConstraints, null, rc, portMapping);
pceGraph = new PceGraph(pceCalc.getaendPceNode(), pceCalc.getzendPceNode(),
pceCalc.getAllPceNodes(), pceCalc.getAllPceLinks(), pceHardConstraints,
null, rc, StringConstants.SERVICE_TYPE_OTUC4, netTransServ);
- Assert.assertEquals(pceGraph.calcPath(), true);
- Assert.assertEquals(Optional.ofNullable(pceGraph.getmargin()),
- Optional.ofNullable(1.4432381874659086));
+ assertEquals(pceGraph.calcPath(), true);
+ assertEquals(Optional.ofNullable(pceGraph.getmargin()), Optional.ofNullable(1.4432381874659086));
}
@Test
- public void clacOpticalTunnelOTUC4() {
+ void clacOpticalTunnelOTUC4() {
PceCalculation pceCalc = new PceCalculation(getPCE1Request(Uint32.valueOf(400), ServiceFormat.OC,
"OpenROADM-1", "Node1", "DEG1-PP-TX", "OpenROADM-5", "Node5", "DEG3-PP-TX"),
netTransServ, pceHardConstraints, null, rc, portMapping);
pceGraph = new PceGraph(pceCalc.getaendPceNode(), pceCalc.getzendPceNode(),
pceCalc.getAllPceNodes(), pceCalc.getAllPceLinks(), pceHardConstraints,
null, rc, StringConstants.SERVICE_TYPE_OTUC4, netTransServ);
- Assert.assertEquals(pceGraph.calcPath(), true);
- Assert.assertEquals(Optional.ofNullable(pceGraph.getmargin()),
- Optional.ofNullable(0.0));
+ assertEquals(pceGraph.calcPath(), true);
+ assertEquals(Optional.ofNullable(pceGraph.getmargin()), Optional.ofNullable(0.0));
}
@Test
- public void clacPath100GEnoPort() {
+ void clacPath100GEnoPort() {
PceCalculation pceCalc = new PceCalculation(getPCE2Request(Uint32.valueOf(100), ServiceFormat.Ethernet,
"XPONDER-1", "Node1", "Client-1", "XPONDER-3", "Node3", "Client-1"),
netTransServ, pceHardConstraints, null, rc, portMapping);
pceGraph = new PceGraph(pceCalc.getaendPceNode(), pceCalc.getzendPceNode(),
pceCalc.getAllPceNodes(), pceCalc.getAllPceLinks(), pceHardConstraints,
null, rc, StringConstants.SERVICE_TYPE_100GE_T, netTransServ);
- Assert.assertEquals(pceGraph.calcPath(), true);
- Assert.assertEquals(Optional.ofNullable(pceGraph.getmargin()),
- Optional.ofNullable(3.0919881995992924));
+ assertEquals(pceGraph.calcPath(), true);
+ assertEquals(Optional.ofNullable(pceGraph.getmargin()), Optional.ofNullable(3.0919881995992924));
}
@Test
- public void clacPathPropagationDelay() {
+ void clacPathPropagationDelay() {
PceCalculation pceCalc = new PceCalculation(getPCE1Request(Uint32.valueOf(100), ServiceFormat.Ethernet,
"XPONDER-1", "Node1", "Client-1", "XPONDER-3", "Node3", "Client-1"),
netTransServ, pceHardConstraints, null, rc, portMapping);
null, rc, StringConstants.SERVICE_TYPE_100GE_T, netTransServ);
pceGraph.setConstrains(pceHardConstraints, null);
- Assert.assertEquals(pceGraph.calcPath(), true);
- Assert.assertEquals(Optional.ofNullable(pceGraph.getPathAtoZ().get(2).getLatency()),
+ assertEquals(pceGraph.calcPath(), true);
+ assertEquals(Optional.ofNullable(pceGraph.getPathAtoZ().get(2).getLatency()),
Optional.ofNullable(1.0));
- Assert.assertEquals(pceGraph.getReturnStructure().getRate(), 100);
+ assertEquals(pceGraph.getReturnStructure().getRate(), 100);
}
- @Test(expected = Exception.class)
- public void clacPath10GE2() {
- pceGraph = getOtnPceGraph(StringConstants.SERVICE_TYPE_10GE);
- Assert.assertEquals(pceGraph.calcPath(), false);
+ //FIXME: Review this test. Getting NPE is never normal!
+ @Test
+ void clacPath10GE2() {
+ assertThrows(NullPointerException.class, () -> {
+ getOtnPceGraph(StringConstants.SERVICE_TYPE_10GE);
+ });
+// assertEquals(pceGraph.calcPath(), false);
}
- @Test(expected = Exception.class)
- public void clacPath1GE() {
- pceGraph = getOtnPceGraph(StringConstants.SERVICE_TYPE_1GE);
- Assert.assertEquals(pceGraph.calcPath(), false);
+ //FIXME: Review this test. Getting NPE is never normal!
+ @Test
+ void clacPath1GE() {
+ assertThrows(NullPointerException.class, () -> {
+ getOtnPceGraph(StringConstants.SERVICE_TYPE_1GE);
+ });
+// assertEquals(pceGraph.calcPath(), false);
}
private PceGraph getOtnPceGraph(String type) {
// Build Link
- link1 = NodeUtils.createRoadmToRoadm("optical",
- "optical2",
- "DEG1-TTP-TX", "DEG1-TTP-RX").build();
+ link1 = NodeUtils.createRoadmToRoadm("optical", "optical2", "DEG1-TTP-TX", "DEG1-TTP-RX").build();
node = NodeUtils.getOTNNodeBuilder(NodeUtils.geSupportingNodes(), OpenroadmTpType.XPONDERNETWORK).build();
allPceNodes = Map.of(
new NodeId("optical"), pceOtnNode,
new NodeId("optical2"), pceOtnNode2);
- return new PceGraph(pceOtnNode, pceOtnNode2, allPceNodes,
- allPceLinks, pceHardConstraints,
- null, new PceResult(),
- type, null);
+ return new PceGraph(pceOtnNode, pceOtnNode2, allPceNodes, allPceLinks, pceHardConstraints, null,
+ new PceResult(), type, null);
}
private void saveOpenRoadmNetwork(Network network, String networkId)
.build())
.build();
}
-
}
package org.opendaylight.transportpce.pce.impl;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
import org.eclipse.jdt.annotation.NonNull;
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.Mockito;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.transportpce.common.network.NetworkTransactionImpl;
private ObjectRegistration<TransportpcePceService> rpcRegistration;
private PceProvider pceProvider;
- @Before
- public void setUp() {
- rpcService = Mockito.mock(RpcProviderService.class);
+ @BeforeEach
+ void setUp() {
+ rpcService = mock(RpcProviderService.class);
notificationPublishService = new NotificationPublishServiceMock();
networkTransaction = new NetworkTransactionImpl(getDataBroker());
pathComputationService = new PathComputationServiceImpl(networkTransaction, notificationPublishService,
}
@Test
- public void testInit() {
+ void testInit() {
this.rpcRegistration = new ObjectRegistration<TransportpcePceService>() {
@NonNull
@Override
}
};
- Mockito
- .when(rpcService
- .registerRpcImplementation(eq(TransportpcePceService.class), Mockito.any()))
- .thenReturn(rpcRegistration);
+ when(rpcService.registerRpcImplementation(eq(TransportpcePceService.class), any())).thenReturn(rpcRegistration);
pceProvider.init();
pceProvider.close();
}
-
}
package org.opendaylight.transportpce.pce.impl;
-import static org.junit.Assert.assertNotNull;
+
+import static org.junit.jupiter.api.Assertions.assertNotNull;
import java.util.concurrent.ExecutionException;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.mockito.Mock;
import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.transportpce.common.mapping.PortMapping;
@Mock
private PortMapping portMapping;
- @Before
- public void setUp() throws ExecutionException, InterruptedException {
+ @BeforeEach
+ void setUp() throws ExecutionException, InterruptedException {
PceTestUtils.writeNetworkIntoDataStore(getDataBroker(), getDataStoreContextUtil(),
TransactionUtils.getNetworkForSpanLoss());
notificationPublishService = new NotificationPublishServiceMock();
pathComputationService = new PathComputationServiceImpl(networkTransaction, notificationPublishService,
null, portMapping);
pceServiceRPC = new PceServiceRPCImpl(pathComputationService);
-
}
@Test
- public void testCancelResourceReserve() {
+ void testCancelResourceReserve() {
CancelResourceReserveInputBuilder cancelResourceReserveInput = new CancelResourceReserveInputBuilder();
assertNotNull(pceServiceRPC.cancelResourceReserve(cancelResourceReserveInput.build()));
}
@Test
- public void testPathComputationRequest() {
+ void testPathComputationRequest() {
assertNotNull(pceServiceRPC.pathComputationRequest(PceTestData.getPCERequest()));
}
@Test
- public void testPathComputationRerouteRequest() {
+ void testPathComputationRerouteRequest() {
assertNotNull(pceServiceRPC.pathComputationRerouteRequest(PceTestData.getPCERerouteRequest()));
}
@Test
- public void testPathComputationRequestCoRoutingOrGeneral2() {
- assertNotNull(pceServiceRPC.pathComputationRequest(
- PceTestData.getPathComputationRequestInputWithCoRoutingOrGeneral2()));
+ void testPathComputationRequestCoRoutingOrGeneral2() {
+ assertNotNull(
+ pceServiceRPC.pathComputationRequest(PceTestData.getPathComputationRequestInputWithCoRoutingOrGeneral2()));
}
}
*/
package org.opendaylight.transportpce.pce.networkanalyzer;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.when;
import java.util.concurrent.ExecutionException;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.jupiter.MockitoExtension;
import org.opendaylight.transportpce.common.StringConstants;
import org.opendaylight.transportpce.common.mapping.PortMapping;
import org.opendaylight.transportpce.common.network.NetworkTransactionImpl;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev220316.network.nodes.NodeInfoBuilder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.types.rev191129.NodeTypes;
-@RunWith(MockitoJUnitRunner.StrictStubs.class)
+@ExtendWith(MockitoExtension.class)
public class PceCalculationTest extends AbstractTest {
private PceCalculation pceCalculation;
@Mock
private PortMapping portMapping;
- // setup object
- @Before
- public void setUp() throws ExecutionException, InterruptedException {
+ @BeforeEach
+ void setUp() throws ExecutionException, InterruptedException {
pceResult.setRC("200");
PceTestUtils.writeNetworkIntoDataStore(getDataBroker(), getDataStoreContextUtil(),
TransactionUtils.getNetworkForSpanLoss());
.build();
NodeInfo info = new NodeInfoBuilder().setNodeType(NodeTypes.Xpdr).build();
Nodes node = new NodesBuilder().withKey(new NodesKey("node")).setNodeId("node").setNodeInfo(info).build();
- when(portMapping.getMapping(anyString(), anyString())).thenReturn(mapping);
+ lenient().when(portMapping.getMapping(anyString(), anyString())).thenReturn(mapping);
when(portMapping.getNode(anyString())).thenReturn(node);
}
@Test
- public void testPceCalculationValues() {
+ void testPceCalculationValues() {
pceCalculation = new PceCalculation(
PceTestData.getPCERequest(),
new NetworkTransactionImpl(getDataBroker()),
pceResult,
portMapping);
pceCalculation.retrievePceNetwork();
- Assert.assertEquals(StringConstants.SERVICE_TYPE_100GE_T, pceCalculation.getServiceType());
- Assert.assertNotNull(pceCalculation.getReturnStructure());
-
- Assert.assertNull(pceCalculation.getaendPceNode());
- Assert.assertNull(pceCalculation.getzendPceNode());
+ assertEquals(StringConstants.SERVICE_TYPE_100GE_T, pceCalculation.getServiceType());
+ assertNotNull(pceCalculation.getReturnStructure());
+ assertNull(pceCalculation.getaendPceNode());
+ assertNull(pceCalculation.getzendPceNode());
}
@Test
- public void testPceCalculationValues2() {
+ void testPceCalculationValues2() {
pceCalculation = new PceCalculation(
PceTestData.getPathComputationRequestInputWithCoRoutingOrGeneral(),
new NetworkTransactionImpl(getDataBroker()),
pceConstraintsCalc.getPceSoftConstraints(),
pceResult, portMapping);
pceCalculation.retrievePceNetwork();
- Assert.assertEquals(StringConstants.SERVICE_TYPE_100GE_T, pceCalculation.getServiceType());
- Assert.assertNotNull(pceCalculation.getReturnStructure());
-
- Assert.assertNull(pceCalculation.getaendPceNode());
- Assert.assertNull(pceCalculation.getzendPceNode());
+ assertEquals(StringConstants.SERVICE_TYPE_100GE_T, pceCalculation.getServiceType());
+ assertNotNull(pceCalculation.getReturnStructure());
+ assertNull(pceCalculation.getaendPceNode());
+ assertNull(pceCalculation.getzendPceNode());
}
@Test
- public void testPceCalculationValues42() {
+ void testPceCalculationValues42() {
PathComputationRequestInput input = PceTestData.getPathComputationRequestInputWithCoRoutingOrGeneral2();
pceConstraintsCalc = new PceConstraintsCalc(input,
new NetworkTransactionImpl(getDataBroker()));
pceConstraintsCalc.getPceSoftConstraints(),
pceResult, portMapping);
pceCalculation.retrievePceNetwork();
- Assert.assertEquals(StringConstants.SERVICE_TYPE_100GE_T, pceCalculation.getServiceType());
- Assert.assertNotNull(pceCalculation.getReturnStructure());
-
- Assert.assertNull(pceCalculation.getaendPceNode());
- Assert.assertNull(pceCalculation.getzendPceNode());
+ assertEquals(StringConstants.SERVICE_TYPE_100GE_T, pceCalculation.getServiceType());
+ assertNotNull(pceCalculation.getReturnStructure());
+ assertNull(pceCalculation.getaendPceNode());
+ assertNull(pceCalculation.getzendPceNode());
}
}
package org.opendaylight.transportpce.pce.networkanalyzer;
-import static org.junit.Assert.assertEquals;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import java.math.RoundingMode;
import java.util.HashMap;
import java.util.Map;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.opendaylight.transportpce.common.NetworkUtils;
@Mock
private PortMapping portMapping;
- @Before
- public void setup() {
+ @BeforeEach
+ void setup() {
MockitoAnnotations.openMocks(this);
}
@Test
- public void testBuildPceLinkRoadmToRoadm() {
+ void testBuildPceLinkRoadmToRoadm() {
Node node = getNodeBuilder(geSupportingNodes()).setNodeId(new NodeId("test")).build();
pceLink = new PceLink(
createRoadmToRoadm("srcNode", "destNode", "srcTp", "destTp").build(),
}
@Test
- public void testBuildPceLinkRoadmToRoadmWithoutPMD() {
+ void testBuildPceLinkRoadmToRoadmWithoutPMD() {
Link link = createRoadmToRoadmWithoutPMD("srcNode", "destNode", "srcTp", "destTp").build();
Node node = getNodeBuilder(geSupportingNodes()).setNodeId(new NodeId("test")).build();
pceLink = new PceLink(
new PceOpticalNode(deviceNodeId2, serviceType, portMapping, node,
OpenroadmNodeType.DEGREE, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50));
- Assert.assertNotNull(MapUtils.getOmsAttributesSpan(link));
- Assert.assertEquals(1, pceLink.getsrlgList().size());
- assertEquals("Checking length loss", 20.0, pceLink.getspanLoss(), 0.005);
- assertEquals("Checking length loss", 825.0, pceLink.getcd(), 0.005);
- assertEquals("Checking PMDvalue of link", 4.0, pceLink.getpmd2(), 0.005);
+ assertNotNull(MapUtils.getOmsAttributesSpan(link));
+ assertEquals(1, pceLink.getsrlgList().size());
+ assertEquals(20.0, pceLink.getspanLoss(), 0.005, "Checking length loss");
+ assertEquals(825.0, pceLink.getcd(), 0.005, "Checking length loss");
+ assertEquals(4.0, pceLink.getpmd2(), 0.005, "Checking PMDvalue of link");
}
@Test
- public void testBuildPceLinkRoadmToRoadmWithoutLinkLatency() {
+ void testBuildPceLinkRoadmToRoadmWithoutLinkLatency() {
Node node = getNodeBuilder(geSupportingNodes()).setNodeId(new NodeId("test")).build();
pceLink = new PceLink(
createRoadmToRoadmWithoutLinkLatency("srcNode", "destNode", "srcTp", "destTp").build(),
}
@Test
- public void testBuildPceLinkOTN() {
+ void testBuildPceLinkOTN() {
// TODO: Modify with OTN node not PceOpticalNode
Node node = getNodeBuilder(geSupportingNodes()).setNodeId(new NodeId("test")).build();
pceLink = new PceLink(
}
@Test
- public void testBuildPceLinkExponder() {
+ void testBuildPceLinkExponder() {
Node node = getNodeBuilder(geSupportingNodes()).setNodeId(new NodeId("test")).build();
pceLink = new PceLink(
createXponderLink("srcNode", "destNode", "srcTp", "destTp").build(),
}
@Test
- public void testCalcSpanOSNR() {
+ void testCalcSpanOSNR() {
Link link = createRoadmToRoadm("srcNode", "destNode", "srcTp", "destTp").build();
Node node = getNodeBuilder(geSupportingNodes()).setNodeId(new NodeId("test")).build();
pceLink = new PceLink(
new PceOpticalNode(deviceNodeId, serviceType, portMapping, node,
OpenroadmNodeType.DEGREE, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50));
- Assert.assertNotNull(MapUtils.getOmsAttributesSpan(link));
- // Assert.assertNotNull(pceLink.getosnr());
- Assert.assertEquals(1, pceLink.getsrlgList().size());
- assertEquals("Checking PMDvalue of link", 0.25, pceLink.getpmd2(), 0.005);
- assertEquals("Checking CDvalue of link", 825, pceLink.getcd(), 0.005);
- // Assert.assertTrue(7.857119000000001 == pceLink.getosnr());
- Assert.assertNull(pceLink.getOppositeLink());
- Assert.assertNull(pceLink.getOppositeLink());
- Assert.assertNotNull(pceLink.getDestTP());
- Assert.assertNotNull(pceLink.getlinkType());
- Assert.assertNotNull(pceLink.getLinkId());
- Assert.assertNotNull(pceLink.getSourceId());
- Assert.assertNotNull(pceLink.getDestId());
+ assertNotNull(MapUtils.getOmsAttributesSpan(link));
+ // assertNotNull(pceLink.getosnr());
+ assertEquals(1, pceLink.getsrlgList().size());
+ assertEquals(0.25, pceLink.getpmd2(), 0.005, "Checking PMDvalue of link");
+ assertEquals(825, pceLink.getcd(), 0.005, "Checking CDvalue of link");
+ // assertTrue(7.857119000000001 == pceLink.getosnr());
+ assertNull(pceLink.getOppositeLink());
+ assertNull(pceLink.getOppositeLink());
+ assertNotNull(pceLink.getDestTP());
+ assertNotNull(pceLink.getlinkType());
+ assertNotNull(pceLink.getLinkId());
+ assertNotNull(pceLink.getSourceId());
+ assertNotNull(pceLink.getDestId());
pceLink.setClient("specific_client");
- Assert.assertTrue(pceLink.getClient().equals("specific_client"));
- Assert.assertNotNull(pceLink.getClient());
- Assert.assertNotNull(pceLink.getLatency());
- Assert.assertNotNull(pceLink.getAvailableBandwidth());
- Assert.assertNotNull(pceLink.getUsedBandwidth());
- Assert.assertNotNull(pceLink.getsourceNetworkSupNodeId());
- Assert.assertNotNull(pceLink.getdestNetworkSupNodeId());
- Assert.assertNotNull(pceLink.getSourceTP());
- Assert.assertNotNull(pceLink.getsourceCLLI());
- Assert.assertNotNull(pceLink.getdestCLLI());
- Assert.assertTrue(pceLink.toString().equals("PceLink type=" + pceLink.getlinkType()
+ assertTrue(pceLink.getClient().equals("specific_client"));
+ assertNotNull(pceLink.getClient());
+ assertNotNull(pceLink.getLatency());
+ assertNotNull(pceLink.getAvailableBandwidth());
+ assertNotNull(pceLink.getUsedBandwidth());
+ assertNotNull(pceLink.getsourceNetworkSupNodeId());
+ assertNotNull(pceLink.getdestNetworkSupNodeId());
+ assertNotNull(pceLink.getSourceTP());
+ assertNotNull(pceLink.getsourceCLLI());
+ assertNotNull(pceLink.getdestCLLI());
+ assertTrue(pceLink.toString().equals("PceLink type=" + pceLink.getlinkType()
+ " ID=" + pceLink.getLinkId().getValue() + " latency=" + pceLink.getLatency().intValue()));
}
@Test
- public void testWrongSpanLoss() {
+ void testWrongSpanLoss() {
Link link = createInvalidRoadmToRoadm("srcNode", "destNode", "srcTp", "destTp").build();
Node node = getNodeBuilder(geSupportingNodes()).setNodeId(new NodeId("test")).build();
pceLink = new PceLink(
new PceOpticalNode(deviceNodeId, serviceType, portMapping, node,
OpenroadmNodeType.DEGREE, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50));
- Assert.assertNull(MapUtils.getOmsAttributesSpan(link));
- Assert.assertNull(pceLink.getpmd2());
- Assert.assertNull(pceLink.getpowerCorrection());
- Assert.assertNull(pceLink.getcd());
+ assertNull(MapUtils.getOmsAttributesSpan(link));
+ assertNull(pceLink.getpmd2());
+ assertNull(pceLink.getpowerCorrection());
+ assertNull(pceLink.getcd());
}
@Test
- public void testExtrapolatedPMD() {
+ void testExtrapolatedPMD() {
Link link = createRoadmToRoadmWithoutPMD("srcNode", "destNode", "srcTp", "destTp").build();
Node node = getNodeBuilder(geSupportingNodes()).setNodeId(new NodeId("test")).build();
pceLink = new PceLink(
new PceOpticalNode(deviceNodeId, serviceType, portMapping, node,
OpenroadmNodeType.DEGREE, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50));
- Assert.assertNotNull(MapUtils.getOmsAttributesSpan(link));
- Assert.assertEquals(1, pceLink.getsrlgList().size());
- assertEquals("Checking PMDvalue of link", 4.0, pceLink.getpmd2(), 0.005);
+ assertNotNull(MapUtils.getOmsAttributesSpan(link));
+ assertEquals(1, pceLink.getsrlgList().size());
+ assertEquals(4.0, pceLink.getpmd2(), 0.005, "Checking PMDvalue of link");
}
private static LinkBuilder createOTNLink(String srcNode, String destNode, String srcTp, String destTp) {
.setOperationalState(State.InService).setAdministrativeState(AdminStates.InService).build())
.setSupportingNode(supportingNodes1);
}
-
-}
+}
\ No newline at end of file
package org.opendaylight.transportpce.pce.networkanalyzer;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
import java.util.Arrays;
import java.util.BitSet;
import java.util.HashMap;
import java.util.Map;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.opendaylight.transportpce.common.NetworkUtils;
@Mock
private PortMapping portMapping;
- @Before
- public void setUp() {
+ @BeforeEach
+ void setUp() {
NodeBuilder node1Builder = getNodeBuilder(geSupportingNodes(), OpenroadmTpType.SRGTXRXPP);
node = node1Builder.setNodeId(new NodeId("test")).build();
availableBitSet.set(0,8);
}
@Test
- public void isValidTest() {
+ void isValidTest() {
OpenroadmNodeType nodeType = OpenroadmNodeType.ROADM;
pceOpticalNode = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node, nodeType,
StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50,
GridConstant.SLOT_WIDTH_50);
- Assert.assertTrue(pceOpticalNode.isValid());
+ assertTrue(pceOpticalNode.isValid());
}
@Test
- public void testInitSrgTps() {
+ void testInitSrgTps() {
pceOpticalNode = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node,
OpenroadmNodeType.ROADM, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
pceOpticalNode.initSrgTps();
pceOpticalNode.initXndrTps(ServiceFormat.OMS);
pceOpticalNode.initFrequenciesBitSet();
- Assert.assertFalse(pceOpticalNode.isValid());
- Assert.assertNull(pceOpticalNode.getBitSetData());
- Assert.assertTrue(pceOpticalNode.checkTP("testTP"));
- Assert.assertNull(pceOpticalNode.getAvailableTribPorts());
- Assert.assertNull(pceOpticalNode.getAvailableTribPorts());
- Assert.assertNull(pceOpticalNode.getXpdrClient("test"));
+ assertFalse(pceOpticalNode.isValid());
+ assertNull(pceOpticalNode.getBitSetData());
+ assertTrue(pceOpticalNode.checkTP("testTP"));
+ assertNull(pceOpticalNode.getAvailableTribPorts());
+ assertNull(pceOpticalNode.getAvailableTribPorts());
+ assertNull(pceOpticalNode.getXpdrClient("test"));
}
@Test
- public void testInitXndrTpSrgTypes() {
+ void testInitXndrTpSrgTypes() {
NodeBuilder node1Builder = getNodeBuilder(geSupportingNodes(), OpenroadmTpType.XPONDERNETWORK);
Node specificNode = node1Builder.build();
pceOpticalNode = new PceOpticalNode(deviceNodeId, serviceType, portMapping, specificNode,
OpenroadmNodeType.SRG, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50);
pceOpticalNode.initFrequenciesBitSet();
- Assert.assertTrue(pceOpticalNode.isValid());
- Assert.assertEquals(availableBitSet, pceOpticalNode.getBitSetData().get(88,96));
- Assert.assertTrue(pceOpticalNode.checkTP("testTP"));
+ assertTrue(pceOpticalNode.isValid());
+ assertEquals(availableBitSet, pceOpticalNode.getBitSetData().get(88,96));
+ assertTrue(pceOpticalNode.checkTP("testTP"));
}
@Test
- public void testInitXndrTpDegTypes() {
+ void testInitXndrTpDegTypes() {
pceOpticalNode = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node,
OpenroadmNodeType.DEGREE, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50);
pceOpticalNode.initFrequenciesBitSet();
- Assert.assertTrue(pceOpticalNode.isValid());
- Assert.assertEquals(usedBitSet,pceOpticalNode.getBitSetData().get(88,96));
- Assert.assertTrue(pceOpticalNode.checkTP("testTP"));
+ assertTrue(pceOpticalNode.isValid());
+ assertEquals(usedBitSet,pceOpticalNode.getBitSetData().get(88,96));
+ assertTrue(pceOpticalNode.checkTP("testTP"));
}
@Test
- public void testInitXndrTpXpondrTypes() {
+ void testInitXndrTpXpondrTypes() {
pceOpticalNode = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node,
OpenroadmNodeType.XPONDER, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50);
pceOpticalNode.initFrequenciesBitSet();
- Assert.assertTrue(pceOpticalNode.isValid());
- Assert.assertEquals(availableBitSet, pceOpticalNode.getBitSetData().get(88,96));
- Assert.assertTrue(pceOpticalNode.checkTP("testTP"));
+ assertTrue(pceOpticalNode.isValid());
+ assertEquals(availableBitSet, pceOpticalNode.getBitSetData().get(88,96));
+ assertTrue(pceOpticalNode.checkTP("testTP"));
}
@Test
- public void testinitFrequenciesBitSet() {
+ void testinitFrequenciesBitSet() {
pceOpticalNode = new PceOpticalNode(null, null, null, node,
OpenroadmNodeType.ROADM, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50);
pceOpticalNode.initXndrTps(ServiceFormat.OMS);
pceOpticalNode.initFrequenciesBitSet();
- Assert.assertFalse(pceOpticalNode.isValid());
- Assert.assertNull(pceOpticalNode.getBitSetData());
- Assert.assertTrue(pceOpticalNode.checkTP("testTP"));
+ assertFalse(pceOpticalNode.isValid());
+ assertNull(pceOpticalNode.getBitSetData());
+ assertTrue(pceOpticalNode.checkTP("testTP"));
}
@Test
- public void testGetRdmSrgClient() {
+ void testGetRdmSrgClient() {
pceOpticalNode = new PceOpticalNode(null, null, null, node,
OpenroadmNodeType.ROADM, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50);
pceOpticalNode.initSrgTps();
- Assert.assertNull(pceOpticalNode.getRdmSrgClient("7", StringConstants.SERVICE_DIRECTION_AZ));
- Assert.assertFalse(pceOpticalNode.isValid());
- Assert.assertNull(pceOpticalNode.getBitSetData());
- Assert.assertTrue(pceOpticalNode.checkTP("testTP"));
+ assertNull(pceOpticalNode.getRdmSrgClient("7", StringConstants.SERVICE_DIRECTION_AZ));
+ assertFalse(pceOpticalNode.isValid());
+ assertNull(pceOpticalNode.getBitSetData());
+ assertTrue(pceOpticalNode.checkTP("testTP"));
}
@Test
- public void testGetRdmSrgClientEmpty() {
+ void testGetRdmSrgClientEmpty() {
NodeBuilder node1Builder = getNodeBuilderEmpty(geSupportingNodes(), OpenroadmTpType.SRGTXRXPP);
Node specificNode = node1Builder.setNodeId(new NodeId("test")).build();
pceOpticalNode = new PceOpticalNode(null, null, null, specificNode,
pceOpticalNode.initSrgTps();
pceOpticalNode.initFrequenciesBitSet();
pceOpticalNode.initXndrTps(ServiceFormat.OMS);
- Assert.assertNull(pceOpticalNode.getRdmSrgClient("7" ,StringConstants.SERVICE_DIRECTION_AZ));
- Assert.assertFalse(pceOpticalNode.isValid());
- Assert.assertNull(pceOpticalNode.getBitSetData());
- Assert.assertTrue(pceOpticalNode.checkTP("testTP"));
+ assertNull(pceOpticalNode.getRdmSrgClient("7" ,StringConstants.SERVICE_DIRECTION_AZ));
+ assertFalse(pceOpticalNode.isValid());
+ assertNull(pceOpticalNode.getBitSetData());
+ assertTrue(pceOpticalNode.checkTP("testTP"));
}
@Test
- public void testGetRdmSrgClientDeg() {
+ void testGetRdmSrgClientDeg() {
pceOpticalNode = new PceOpticalNode(null, null, null, node,
OpenroadmNodeType.DEGREE, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50);
pceOpticalNode.initSrgTps();
- Assert.assertNull(pceOpticalNode.getRdmSrgClient("7" ,StringConstants.SERVICE_DIRECTION_AZ));
- Assert.assertFalse(pceOpticalNode.isValid());
- Assert.assertNull(pceOpticalNode.getBitSetData());
- Assert.assertTrue(pceOpticalNode.checkTP("testTP"));
+ assertNull(pceOpticalNode.getRdmSrgClient("7" ,StringConstants.SERVICE_DIRECTION_AZ));
+ assertFalse(pceOpticalNode.isValid());
+ assertNull(pceOpticalNode.getBitSetData());
+ assertTrue(pceOpticalNode.checkTP("testTP"));
}
@Test
- public void testGetRdmSrgClientsrgtxcp() {
+ void testGetRdmSrgClientsrgtxcp() {
NodeBuilder node1Builder = getNodeBuilder(geSupportingNodes(), OpenroadmTpType.SRGTXCP);
Node specificNode = node1Builder.build();
pceOpticalNode = new PceOpticalNode(null, null, null, specificNode,
OpenroadmNodeType.ROADM, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50);
pceOpticalNode.initSrgTps();
- Assert.assertFalse(pceOpticalNode.isValid());
- Assert.assertNull(pceOpticalNode.getBitSetData());
- Assert.assertTrue(pceOpticalNode.checkTP("testTP"));
- Assert.assertNull(pceOpticalNode.getRdmSrgClient("5", StringConstants.SERVICE_DIRECTION_AZ));
+ assertFalse(pceOpticalNode.isValid());
+ assertNull(pceOpticalNode.getBitSetData());
+ assertTrue(pceOpticalNode.checkTP("testTP"));
+ assertNull(pceOpticalNode.getRdmSrgClient("5", StringConstants.SERVICE_DIRECTION_AZ));
}
@Test
- public void testGetRdmSrgClientDegreerxtpp() {
+ void testGetRdmSrgClientDegreerxtpp() {
NodeBuilder node1Builder = getNodeBuilder(geSupportingNodes(), OpenroadmTpType.DEGREERXTTP);
node = node1Builder.build();
pceOpticalNode = new PceOpticalNode(null, null, null, node,
OpenroadmNodeType.ROADM, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50);
pceOpticalNode.initSrgTps();
- Assert.assertNull(pceOpticalNode.getRdmSrgClient("2" ,StringConstants.SERVICE_DIRECTION_AZ));
- Assert.assertFalse(pceOpticalNode.isValid());
- Assert.assertNull(pceOpticalNode.getBitSetData());
- Assert.assertTrue(pceOpticalNode.checkTP("testTP"));
+ assertNull(pceOpticalNode.getRdmSrgClient("2" ,StringConstants.SERVICE_DIRECTION_AZ));
+ assertFalse(pceOpticalNode.isValid());
+ assertNull(pceOpticalNode.getBitSetData());
+ assertTrue(pceOpticalNode.checkTP("testTP"));
}
private Map<SupportingNodeKey,SupportingNode> geSupportingNodes() {
.build();
Node1 node11 = new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210.Node1Builder()
.setAdministrativeState(AdminStates.InService).setOperationalState(State.InService).build();
-
-
return new NodeBuilder()
.setNodeId(new NodeId("node_test"))
.withKey(new NodeKey(new NodeId("node 1")))
.build();
Node1 node11 = new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210.Node1Builder()
.setAdministrativeState(AdminStates.InService).setOperationalState(State.InService).build();
-
-
return new NodeBuilder()
.setNodeId(new NodeId("node_test"))
.withKey(new NodeKey(new NodeId("node 1")))
}
private TerminationPoint1Builder getTerminationPoint1Builder(OpenroadmTpType openroadmTpType) {
-
return new TerminationPoint1Builder().setTpType(openroadmTpType).setOperationalState(State.InService)
.setAdministrativeState(AdminStates.InService);
.setXpdrNetworkAttributes(new XpdrNetworkAttributesBuilder()
.setTailEquipmentId("destNode" + "--" + "destTp").build());
}
-
}
package org.opendaylight.transportpce.pce.networkanalyzer;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
import java.util.HashMap;
import java.util.Map;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.opendaylight.transportpce.common.NetworkUtils;
import org.opendaylight.transportpce.common.StringConstants;
import org.opendaylight.transportpce.common.fixedflex.GridUtils;
private PceOtnNode pceOtnNode;
private Node node;
- @Before
- public void setUp() {
+ @BeforeEach
+ void setUp() {
node = getNodeBuilder(geSupportingNodes(), OpenroadmTpType.XPONDERNETWORK).build();
}
@Test
- public void testInitXndrTpsODU4() {
+ void testInitXndrTpsODU4() {
pceOtnNode = new PceOtnNode(node, OpenroadmNodeType.MUXPDR,
new NodeId("optical"), ServiceFormat.OMS.getName(), StringConstants.SERVICE_TYPE_ODU4, null);
pceOtnNode.initXndrTps("AZ");
pceOtnNode.checkAvailableTribPort();
pceOtnNode.checkAvailableTribSlot();
- Assert.assertTrue("valid otn service type " , pceOtnNode.isValid());
- Assert.assertNotNull("tpAvailableTribPort isn't null !" , pceOtnNode.getAvailableTribPorts());
+ assertTrue(pceOtnNode.isValid(), "valid otn service type ");
+ assertNotNull(pceOtnNode.getAvailableTribPorts(), "tpAvailableTribPort isn't null !");
}
@Test
- public void testInitXndrTps10GE() {
+ void testInitXndrTps10GE() {
pceOtnNode = new PceOtnNode(node, OpenroadmNodeType.MUXPDR,
new NodeId("optical"), ServiceFormat.OMS.getName(), StringConstants.SERVICE_TYPE_10GE, null);
pceOtnNode.initXndrTps("mode");
pceOtnNode.checkAvailableTribPort();
pceOtnNode.checkAvailableTribSlot();
- Assert.assertFalse("not valid otn service type" , pceOtnNode.isValid());
+ assertFalse(pceOtnNode.isValid(), "not valid otn service type");
}
@Test
- public void testInitXndrTps10GXponderClient1() {
+ void testInitXndrTps10GXponderClient1() {
node = getNodeBuilder(geSupportingNodes(), OpenroadmTpType.XPONDERCLIENT).build();
pceOtnNode = new PceOtnNode(node, OpenroadmNodeType.ROADM,
new NodeId("optical"), ServiceFormat.OMS.getName(), StringConstants.SERVICE_TYPE_10GE, null);
pceOtnNode.initXndrTps("mode");
pceOtnNode.checkAvailableTribPort();
pceOtnNode.checkAvailableTribSlot();
- Assert.assertFalse("not valid otn service type", pceOtnNode.isValid());
- Assert.assertTrue("this.nodeType isn'tOpenroadmNodeType.TPDR" ,
- pceOtnNode.validateSwitchingPoolBandwidth(null,null,1L));
+ assertFalse(pceOtnNode.isValid(), "not valid otn service type");
+ assertTrue(pceOtnNode.validateSwitchingPoolBandwidth(null, null, 1L),
+ "this.nodeType isn'tOpenroadmNodeType.TPDR");
}
@Test
- public void testInitXndrTps1GXponderClient() {
+ void testInitXndrTps1GXponderClient() {
node = getNodeBuilder(geSupportingNodes(), OpenroadmTpType.XPONDERCLIENT).build();
pceOtnNode = new PceOtnNode(node, OpenroadmNodeType.MUXPDR,
new NodeId("optical"), ServiceFormat.OMS.getName(), StringConstants.SERVICE_TYPE_1GE, null);
pceOtnNode.initXndrTps("mode");
pceOtnNode.checkAvailableTribPort();
pceOtnNode.checkAvailableTribSlot();
- Assert.assertFalse("not valid otn service type" , pceOtnNode.isValid());
+ assertFalse(pceOtnNode.isValid(), "not valid otn service type");
}
@Test
- public void testInitXndrTps10GXponderClient() {
+ void testInitXndrTps10GXponderClient() {
pceOtnNode = new PceOtnNode(node, OpenroadmNodeType.MUXPDR,
new NodeId("optical"), ServiceFormat.OMS.getName(), StringConstants.SERVICE_TYPE_10GE, null);
pceOtnNode.validateXponder("optical", "sl");
pceOtnNode.initXndrTps("AZ");
pceOtnNode.checkAvailableTribPort();
pceOtnNode.checkAvailableTribSlot();
- Assert.assertFalse("not valid otn service type" , pceOtnNode.isValid());
- Assert.assertFalse("checkTp returns false by default " , pceOtnNode.checkTP("tp"));
+ assertFalse(pceOtnNode.isValid(), "not valid otn service type");
+ assertFalse(pceOtnNode.checkTP("tp"), "checkTp returns false by default");
}
private Map<SupportingNodeKey, SupportingNode> geSupportingNodes() {
.build();
Node1 node11 = new org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210.Node1Builder()
.setOperationalState(State.InService).setAdministrativeState(AdminStates.InService).build();
-
return new NodeBuilder()
.setNodeId(new NodeId("node_test"))
.withKey(new NodeKey(new NodeId("node 1")))
*/
package org.opendaylight.transportpce.pce.networkanalyzer;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
import java.util.ArrayList;
import java.util.List;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.opendaylight.transportpce.test.AbstractTest;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev210924.OpucnTribSlotDef;
private PceResult pceResult = null;
- @Before
- public void setUp() {
+ @BeforeEach
+ void setUp() {
pceResult = new PceResult();
}
@Test
- public void serviceTypeTest() {
+ void serviceTypeTest() {
String serviceType = "some-service";
pceResult.setServiceType(serviceType);
- Assert.assertEquals(pceResult.getServiceType(), serviceType);
+ assertEquals(pceResult.getServiceType(), serviceType);
}
@Test
- public void setResultTribSlotNbTest() {
+ void setResultTribSlotNbTest() {
OpucnTribSlotDef minOpucnTs = new OpucnTribSlotDef("1.1");
OpucnTribSlotDef maxOpucnTs = new OpucnTribSlotDef("1.20");
List<OpucnTribSlotDef> minmaxTpTsList = new ArrayList<>();
minmaxTpTsList.add(minOpucnTs);
minmaxTpTsList.add(maxOpucnTs);
pceResult.setResultTribPortTribSlot(minmaxTpTsList);
- Assert.assertEquals(pceResult.getResultTribPortTribSlot().get(0), new OpucnTribSlotDef("1.1"));
- Assert.assertEquals(pceResult.getResultTribPortTribSlot().get(1), new OpucnTribSlotDef("1.20"));
+ assertEquals(pceResult.getResultTribPortTribSlot().get(0), new OpucnTribSlotDef("1.1"));
+ assertEquals(pceResult.getResultTribPortTribSlot().get(1), new OpucnTribSlotDef("1.20"));
}
@Test
- public void calcMessageTest() {
+ void calcMessageTest() {
pceResult.setCalcMessage("some-message");
pceResult.setRC("200");
- Assert.assertEquals(pceResult.getMessage(), "Path is calculated by PCE");
+ assertEquals(pceResult.getMessage(), "Path is calculated by PCE");
}
@Test
- public void waveLengthTest() {
- Assert.assertEquals(0, pceResult.getResultWavelength());
+ void waveLengthTest() {
+ assertEquals(0, pceResult.getResultWavelength());
pceResult.setResultWavelength(12);
- Assert.assertEquals(12, pceResult.getResultWavelength());
+ assertEquals(12, pceResult.getResultWavelength());
}
@Test
- public void localCause() {
+ void localCause() {
pceResult.setLocalCause(PceResult.LocalCause.INT_PROBLEM);
- Assert.assertEquals(pceResult.getLocalCause(), PceResult.LocalCause.INT_PROBLEM);
+ assertEquals(pceResult.getLocalCause(), PceResult.LocalCause.INT_PROBLEM);
}
}
*/
package org.opendaylight.transportpce.pce.service;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
import java.util.Map;
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import org.opendaylight.transportpce.common.network.NetworkTransactionService;
import org.opendaylight.transportpce.pce.utils.PceTestData;
private PathComputationServiceImpl pathComputationServiceImpl;
private static NetworkTransactionService networkTransactionService = null;
- @Before
- public void setUp() {
+ @BeforeEach
+ void setUp() {
networkTransactionService = Mockito.mock(NetworkTransactionService.class);
pathComputationServiceImpl = new PathComputationServiceImpl(
networkTransactionService,
}
@Test
- public void pathComputationRequestTest() {
+ void pathComputationRequestTest() {
pathComputationServiceImpl.generateGnpyResponse(null,"path");
- Assert.assertNotNull(
- pathComputationServiceImpl.pathComputationRequest(PceTestData.getPCE_simpletopology_test1_request()));
-
+ assertNotNull(
+ pathComputationServiceImpl.pathComputationRequest(PceTestData.getPCE_simpletopology_test1_request()));
}
@Test
- public void testPathComputationRequestNoPath() {
+ void testPathComputationRequestNoPath() {
Response response = new ResponseBuilder()
.withKey(new ResponseKey("responseId")).setResponseType(new NoPathCaseBuilder()
.setNoPath(new NoPathBuilder().setNoPath("no path").build()).build()).build();
pathComputationServiceImpl.generateGnpyResponse(response,"path");
- Assert.assertNotNull(
- pathComputationServiceImpl.pathComputationRequest(PceTestData.getPCE_test3_request_54()));
-
+ assertNotNull(pathComputationServiceImpl.pathComputationRequest(PceTestData.getPCE_test3_request_54()));
}
@Test
- public void testPathComputationRequestPathCase() {
+ void testPathComputationRequestPathCase() {
PathMetric pathMetric = new PathMetricBuilder()
.setAccumulativeValue(Decimal64.valueOf("21"))
.setMetricType(PathBandwidth.VALUE).build();
.build()).build()).build();
pathComputationServiceImpl.generateGnpyResponse(response,"path");
- Assert.assertNotNull(
- pathComputationServiceImpl.pathComputationRequest(PceTestData.getPCE_test3_request_54()));
-
+ assertNotNull(pathComputationServiceImpl.pathComputationRequest(PceTestData.getPCE_test3_request_54()));
}
@Test
- public void pathComputationRerouteRequestTest() {
+ void pathComputationRerouteRequestTest() {
pathComputationServiceImpl.generateGnpyResponse(null,"path");
- Assert.assertNotNull(pathComputationServiceImpl
- .pathComputationRerouteRequest(PceTestData.getPCEReroute()));
-
+ assertNotNull(pathComputationServiceImpl.pathComputationRerouteRequest(PceTestData.getPCEReroute()));
}
- @After
- public void destroy() {
+ @AfterEach
+ void destroy() {
pathComputationServiceImpl.close();
}
}
Code Review / transportpce.git / commitdiff