| /* |
| * Copyright 2016 Open Networking Foundation |
| * |
| * 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. |
| */ |
| package org.onosproject.tetopology.manager.api; |
| |
| import org.junit.Before; |
| import org.junit.Test; |
| import org.onosproject.tetopology.management.api.link.ConnectivityMatrixId; |
| import org.onosproject.tetopology.management.api.link.ElementType; |
| import org.onosproject.tetopology.management.api.link.Label; |
| import org.onosproject.tetopology.management.api.link.PathElement; |
| import org.onosproject.tetopology.management.api.link.TePathAttributes; |
| import org.onosproject.tetopology.management.api.link.UnderlayAbstractPath; |
| import org.onosproject.tetopology.management.api.link.UnderlayBackupPath; |
| import org.onosproject.tetopology.management.api.node.ConnectivityMatrix; |
| import org.onosproject.tetopology.management.api.node.ConnectivityMatrixKey; |
| import org.onosproject.tetopology.management.api.node.TeNodeKey; |
| import org.onosproject.tetopology.management.api.node.TtpKey; |
| |
| import java.util.ArrayList; |
| import java.util.BitSet; |
| import java.util.List; |
| |
| import static org.junit.Assert.assertFalse; |
| import static org.junit.Assert.assertTrue; |
| |
| |
| /** |
| * Unit tests for TE node APIs. |
| */ |
| public class TeNodeApiTest { |
| private static final long DEFAULT_PROVIDER_ID = 123; |
| private static final long DEFAULT_CLIENT_ID = 456; |
| private static final long DEFAULT_TOPOLOGY_ID = 789; |
| private static final long DEFAULT_TE_NODE_ID = 1234; |
| private static final long DEFAULT_CONNECTIVITY_ENTRY_ID = 5678; |
| private static final long DEFAULT_TTP_ID = 897; |
| private static final String DEFAULT_TOPOLOGY_ID_STRING = |
| "default-topology-123"; |
| private static final long DEFAULT_PATH_ELEMENT_ID = 234; |
| private static final long DEFAULT_UNDERLAY_BACKUP_PATH_IDX = 10; |
| |
| private long providerId; |
| private long clientId; |
| private long topologyId; |
| private long teNodeId; |
| private long connectivityMatrixEntryId; |
| private long pathElementId; |
| private long underlayBackupPathIndex; |
| private long ttpId; |
| |
| private String topologyIdString; |
| |
| @Before |
| public void setUp() { |
| providerId = DEFAULT_PROVIDER_ID; |
| clientId = DEFAULT_CLIENT_ID; |
| topologyId = DEFAULT_TOPOLOGY_ID; |
| teNodeId = DEFAULT_TE_NODE_ID; |
| connectivityMatrixEntryId = DEFAULT_CONNECTIVITY_ENTRY_ID; |
| topologyIdString = DEFAULT_TOPOLOGY_ID_STRING; |
| pathElementId = DEFAULT_PATH_ELEMENT_ID; |
| underlayBackupPathIndex = DEFAULT_UNDERLAY_BACKUP_PATH_IDX; |
| ttpId = DEFAULT_TTP_ID; |
| } |
| |
| @Test |
| public void connectivityMatrixKeyEqualOperatorTest() { |
| ConnectivityMatrixKey key1 = new ConnectivityMatrixKey(providerId, |
| clientId, |
| topologyId, |
| teNodeId, |
| connectivityMatrixEntryId); |
| ConnectivityMatrixKey key2 = new ConnectivityMatrixKey(providerId, |
| clientId, |
| topologyId, |
| teNodeId, |
| connectivityMatrixEntryId); |
| ConnectivityMatrixKey key3 = new ConnectivityMatrixKey(providerId + 1, |
| clientId, |
| topologyId, |
| teNodeId, |
| connectivityMatrixEntryId); |
| ConnectivityMatrixKey key4 = new ConnectivityMatrixKey(providerId, |
| clientId + 1, |
| topologyId, |
| teNodeId, |
| connectivityMatrixEntryId); |
| ConnectivityMatrixKey key5 = new ConnectivityMatrixKey(providerId, |
| clientId, |
| topologyId + 1, |
| teNodeId, |
| connectivityMatrixEntryId); |
| ConnectivityMatrixKey key6 = new ConnectivityMatrixKey(providerId, |
| clientId, |
| topologyId, |
| teNodeId + 1, |
| connectivityMatrixEntryId); |
| ConnectivityMatrixKey key7 = new ConnectivityMatrixKey(providerId, |
| clientId, |
| topologyId, |
| teNodeId, |
| connectivityMatrixEntryId + 1); |
| |
| assertTrue("Two matrix keys must be equal", key1.equals(key2)); |
| |
| assertFalse("Two matrix keys must be unequal", key1.equals(key3)); |
| assertFalse("Two matrix keys must be unequal", key3.equals(key1)); |
| |
| assertFalse("Two matrix keys must be unequal", key1.equals(key4)); |
| assertFalse("Two matrix keys must be unequal", key4.equals(key1)); |
| |
| assertFalse("Two matrix keys must be unequal", key1.equals(key5)); |
| assertFalse("Two matrix keys must be unequal", key5.equals(key1)); |
| |
| assertFalse("Two matrix keys must be unequal", key1.equals(key6)); |
| assertFalse("Two matrix keys must be unequal", key6.equals(key1)); |
| |
| assertFalse("Two matrix keys must be unequal", key1.equals(key7)); |
| assertFalse("Two matrix keys must be unequal", key7.equals(key1)); |
| } |
| |
| @Test |
| public void underlayBackupPathEqualOperatorTest() { |
| ElementType pathElementType1 = new Label(pathElementId + 1); |
| ElementType pathElementType2 = new Label(pathElementId + 2); |
| ElementType pathElementType3 = new Label(pathElementId + 3); |
| ElementType pathElementType4 = new Label(pathElementId + 4); |
| |
| PathElement pathElement1 = new PathElement(pathElementId, teNodeId, |
| pathElementType1, true); |
| PathElement pathElement2 = new PathElement(pathElementId + 1, |
| teNodeId + 1, |
| pathElementType2, true); |
| PathElement pathElement3 = new PathElement(pathElementId + 2, |
| teNodeId + 2, |
| pathElementType3, true); |
| PathElement pathElement4 = new PathElement(pathElementId + 3, |
| teNodeId + 3, |
| pathElementType4, true); |
| |
| List<PathElement> pathElementList1 = new ArrayList<>(); |
| pathElementList1.add(pathElement1); |
| pathElementList1.add(pathElement2); |
| pathElementList1.add(pathElement3); |
| |
| List<PathElement> pathElementList2 = new ArrayList<>(); |
| pathElementList2.add(pathElement1); |
| pathElementList2.add(pathElement2); |
| pathElementList2.add(pathElement4); |
| |
| // bp1 and bp2 are the same. bp3, bp4, and bp5 differ by one |
| // attribute comparing to bp1. |
| UnderlayBackupPath bp1 = new UnderlayBackupPath( |
| underlayBackupPathIndex, pathElementList1, true); |
| UnderlayBackupPath bp2 = new UnderlayBackupPath( |
| underlayBackupPathIndex, pathElementList1, true); |
| |
| UnderlayBackupPath bp3 = new UnderlayBackupPath( |
| underlayBackupPathIndex + 1, pathElementList1, true); |
| UnderlayBackupPath bp4 = new UnderlayBackupPath( |
| underlayBackupPathIndex, pathElementList2, true); |
| UnderlayBackupPath bp5 = new UnderlayBackupPath( |
| underlayBackupPathIndex, pathElementList1, false); |
| |
| |
| assertTrue("Two backup paths must be equal", bp1.equals(bp2)); |
| |
| assertFalse("Two backup paths must be unequal", bp1.equals(bp3)); |
| assertFalse("Two backup paths must be unequal", bp3.equals(bp1)); |
| |
| assertFalse("Two backup paths must be unequal", bp1.equals(bp4)); |
| assertFalse("Two backup paths must be unequal", bp4.equals(bp1)); |
| |
| assertFalse("Two backup paths must be unequal", bp1.equals(bp5)); |
| assertFalse("Two backup paths must be unequal", bp5.equals(bp1)); |
| } |
| |
| |
| @Test |
| public void connectivityMatrixEqualOperatorTest() { |
| long key1 = connectivityMatrixEntryId; |
| long key2 = connectivityMatrixEntryId + 1; |
| |
| ElementType pathElementType1 = new Label(pathElementId + 1); |
| ElementType pathElementType2 = new Label(pathElementId + 2); |
| ElementType pathElementType3 = new Label(pathElementId + 3); |
| ElementType pathElementType4 = new Label(pathElementId + 4); |
| |
| PathElement pathElement1 = new PathElement(pathElementId, teNodeId, |
| pathElementType1, true); |
| PathElement pathElement2 = new PathElement(pathElementId + 1, |
| teNodeId + 1, |
| pathElementType2, true); |
| PathElement pathElement3 = new PathElement(pathElementId + 2, |
| teNodeId + 2, |
| pathElementType3, true); |
| PathElement pathElement4 = new PathElement(pathElementId + 3, |
| teNodeId + 3, |
| pathElementType4, true); |
| |
| List<PathElement> pathElementList1 = new ArrayList<>(); |
| pathElementList1.add(pathElement1); |
| pathElementList1.add(pathElement2); |
| pathElementList1.add(pathElement3); |
| |
| List<PathElement> pathElementList2 = new ArrayList<>(); |
| pathElementList2.add(pathElement1); |
| pathElementList2.add(pathElement2); |
| pathElementList2.add(pathElement4); |
| |
| UnderlayAbstractPath abstractPath1 = new UnderlayAbstractPath( |
| pathElementList1, true); |
| UnderlayAbstractPath abstractPath2 = new UnderlayAbstractPath( |
| pathElementList2, true); |
| |
| ElementType from = new ConnectivityMatrixId(connectivityMatrixEntryId); |
| List<ElementType> mergingList = new ArrayList<>(); |
| mergingList.add(new ConnectivityMatrixId(connectivityMatrixEntryId + 1)); |
| mergingList.add(new ConnectivityMatrixId(connectivityMatrixEntryId + 2)); |
| |
| List<ElementType> constrainList = new ArrayList<>(); |
| constrainList.add(new ConnectivityMatrixId(connectivityMatrixEntryId + 3)); |
| constrainList.add(new ConnectivityMatrixId(connectivityMatrixEntryId + 4)); |
| |
| BitSet flags = new BitSet(1); |
| |
| List<Long> srlgs = new ArrayList<>(); |
| srlgs.add(new Long(10)); |
| TePathAttributes tePathAttributes = new TePathAttributes(new Long(10), |
| new Long(10), |
| srlgs); |
| |
| ConnectivityMatrix matrix1 = new ConnectivityMatrix(key1, |
| from, |
| mergingList, |
| constrainList, |
| flags, |
| tePathAttributes, |
| abstractPath1); |
| ConnectivityMatrix matrix2 = new ConnectivityMatrix(key1, |
| from, |
| mergingList, |
| constrainList, |
| flags, |
| tePathAttributes, |
| abstractPath1); |
| ConnectivityMatrix matrix3 = new ConnectivityMatrix(key1, |
| from, |
| mergingList, |
| constrainList, |
| flags, |
| tePathAttributes, |
| abstractPath2); |
| ConnectivityMatrix matrix4 = new ConnectivityMatrix(key2, |
| from, |
| mergingList, |
| constrainList, |
| flags, |
| tePathAttributes, |
| abstractPath1); |
| |
| assertTrue("Two conn matrices must be equal", matrix1.equals(matrix2)); |
| |
| assertFalse("Two conn matrices must be unequal", matrix1.equals(matrix3)); |
| assertFalse("Two conn matrices must be unequal", matrix3.equals(matrix1)); |
| |
| assertFalse("Two conn matrices must be unequal", matrix1.equals(matrix4)); |
| assertFalse("Two conn matrices must be unequal", matrix4.equals(matrix1)); |
| } |
| |
| @Test |
| public void teNodeKeyEqualOperatorTest() { |
| TeNodeKey key1 = new TeNodeKey(providerId, clientId, |
| topologyId, teNodeId); |
| TeNodeKey key2 = new TeNodeKey(providerId, clientId, |
| topologyId, teNodeId); |
| TeNodeKey key3 = new TeNodeKey(providerId + 1, clientId, |
| topologyId, teNodeId); |
| TeNodeKey key4 = new TeNodeKey(providerId, clientId + 1, |
| topologyId, teNodeId); |
| TeNodeKey key5 = new TeNodeKey(providerId, clientId, |
| topologyId + 1, teNodeId); |
| TeNodeKey key6 = new TeNodeKey(providerId, clientId, |
| topologyId, teNodeId + 1); |
| |
| assertTrue("Two matrix keys must be equal", key1.equals(key2)); |
| |
| assertFalse("Two matrix keys must be unequal", key1.equals(key3)); |
| assertFalse("Two matrix keys must be unequal", key3.equals(key1)); |
| |
| assertFalse("Two matrix keys must be unequal", key1.equals(key4)); |
| assertFalse("Two matrix keys must be unequal", key4.equals(key1)); |
| |
| assertFalse("Two matrix keys must be unequal", key1.equals(key5)); |
| assertFalse("Two matrix keys must be unequal", key5.equals(key1)); |
| |
| assertFalse("Two matrix keys must be unequal", key1.equals(key6)); |
| assertFalse("Two matrix keys must be unequal", key6.equals(key1)); |
| } |
| |
| @Test |
| public void ttpMatrixKeyEqualOperatorTest() { |
| TtpKey key1 = new TtpKey(providerId, clientId, topologyId, |
| teNodeId, ttpId); |
| TtpKey key2 = new TtpKey(providerId, clientId, topologyId, |
| teNodeId, ttpId); |
| TtpKey key3 = new TtpKey(providerId + 1, clientId, topologyId, |
| teNodeId, ttpId); |
| TtpKey key4 = new TtpKey(providerId, clientId + 1, topologyId, |
| teNodeId, ttpId); |
| TtpKey key5 = new TtpKey(providerId, clientId, topologyId + 1, |
| teNodeId, ttpId); |
| TtpKey key6 = new TtpKey(providerId, clientId, topologyId, |
| teNodeId + 1, ttpId); |
| TtpKey key7 = new TtpKey(providerId, clientId, topologyId, |
| teNodeId, ttpId + 1); |
| |
| assertTrue("Two TTP keys must be equal", key1.equals(key2)); |
| |
| assertFalse("Two TTP keys must be unequal", key1.equals(key3)); |
| assertFalse("Two TTP keys must be unequal", key3.equals(key1)); |
| |
| assertFalse("Two TTP keys must be unequal", key1.equals(key4)); |
| assertFalse("Two TTP keys must be unequal", key4.equals(key1)); |
| |
| assertFalse("Two TTP keys must be unequal", key1.equals(key5)); |
| assertFalse("Two TTP keys must be unequal", key5.equals(key1)); |
| |
| assertFalse("Two TTP keys must be unequal", key1.equals(key6)); |
| assertFalse("Two TTP keys must be unequal", key6.equals(key1)); |
| |
| assertFalse("Two TTP keys must be unequal", key1.equals(key7)); |
| assertFalse("Two TTP keys must be unequal", key7.equals(key1)); |
| } |
| |
| } |