return combinedOptions;
}
- private Option[] getOtherOptions() {
+ private static Option[] getOtherOptions() {
return new Option[] {
vmOption("-javaagent:../jars/org.jacoco.agent.jar=destfile=../../jacoco-it.exec"),
keepRuntimeFolder()
super.getLoggingOption());
}
- private Option[] getPropertiesOptions() {
+ private static Option[] getPropertiesOptions() {
Properties props = new Properties(System.getProperties());
String ipAddressStr = props.getProperty(SouthboundITConstants.SERVER_IPADDRESS,
SouthboundITConstants.DEFAULT_SERVER_IPADDRESS);
}
}
- private Boolean getOvsdbTopology() {
+ private static Boolean getOvsdbTopology() {
LOG.info("getOvsdbTopology: looking for {}...", SouthboundUtils.OVSDB_TOPOLOGY_ID.getValue());
Boolean found = false;
final TopologyId topologyId = SouthboundUtils.OVSDB_TOPOLOGY_ID;
topology);
}
- private Node connectOvsdbNode(final ConnectionInfo connectionInfo) throws InterruptedException {
+ private static Node connectOvsdbNode(final ConnectionInfo connectionInfo) throws InterruptedException {
final InstanceIdentifier<Node> iid = SouthboundUtils.createInstanceIdentifier(connectionInfo);
Assert.assertTrue(
mdsalUtils.put(LogicalDatastoreType.CONFIGURATION, iid, SouthboundUtils.createNode(connectionInfo)));
return node;
}
- private void waitForOperationalCreation(InstanceIdentifier<Node> iid) throws InterruptedException {
+ private static void waitForOperationalCreation(InstanceIdentifier<Node> iid) throws InterruptedException {
synchronized (OPERATIONAL_LISTENER) {
long start = System.currentTimeMillis();
LOG.info("Waiting for OPERATIONAL DataChanged creation on {}", iid);
}
}
- private void waitForOperationalUpdate(InstanceIdentifier<Node> iid) throws InterruptedException {
+ private static void waitForOperationalUpdate(InstanceIdentifier<Node> iid) throws InterruptedException {
synchronized (OPERATIONAL_LISTENER) {
long start = System.currentTimeMillis();
LOG.info("Waiting for OPERATIONAL DataChanged update on {}", iid);
}
}
- private List<ControllerEntry> createControllerEntry(String controllerTarget) {
+ private static List<ControllerEntry> createControllerEntry(String controllerTarget) {
List<ControllerEntry> controllerEntriesList = new ArrayList<>();
controllerEntriesList.add(new ControllerEntryBuilder()
.setTarget(new Uri(controllerTarget))
return protocolList;
}
- private OvsdbTerminationPointAugmentationBuilder createGenericOvsdbTerminationPointAugmentationBuilder() {
+ private static OvsdbTerminationPointAugmentationBuilder createGenericOvsdbTerminationPointAugmentationBuilder() {
OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointAugmentationBuilder =
new OvsdbTerminationPointAugmentationBuilder();
ovsdbTerminationPointAugmentationBuilder.setInterfaceType(
return ovsdbTerminationPointAugmentationBuilder;
}
- private OvsdbTerminationPointAugmentationBuilder createGenericDpdkOvsdbTerminationPointAugmentationBuilder(
+ private static OvsdbTerminationPointAugmentationBuilder createGenericDpdkOvsdbTerminationPointAugmentationBuilder(
final String portName) {
OvsdbTerminationPointAugmentationBuilder ovsdbTerminationBuilder =
createGenericOvsdbTerminationPointAugmentationBuilder();
return ovsdbTerminationBuilder;
}
- private OvsdbTerminationPointAugmentationBuilder createSpecificDpdkOvsdbTerminationPointAugmentationBuilder(
+ private static OvsdbTerminationPointAugmentationBuilder createSpecificDpdkOvsdbTerminationPointAugmentationBuilder(
String testPortname,Class<? extends InterfaceTypeBase> dpdkIfType) {
OvsdbTerminationPointAugmentationBuilder ovsdbTerminationBuilder =
createGenericOvsdbTerminationPointAugmentationBuilder();
return ovsdbTerminationBuilder;
}
- private boolean addTerminationPoint(final NodeId bridgeNodeId, final String portName,
- final OvsdbTerminationPointAugmentationBuilder
- ovsdbTerminationPointAugmentationBuilder)
+ private static boolean addTerminationPoint(final NodeId bridgeNodeId, final String portName,
+ final OvsdbTerminationPointAugmentationBuilder
+ ovsdbTerminationPointAugmentationBuilder)
throws InterruptedException {
InstanceIdentifier<Node> portIid = SouthboundMapper.createInstanceIdentifier(bridgeNodeId);
}
}
- private OvsdbNodeAugmentation getOvsdbNode(ConnectionInfo connectionInfo, LogicalDatastoreType store) {
+ private static OvsdbNodeAugmentation getOvsdbNode(ConnectionInfo connectionInfo, LogicalDatastoreType store) {
InstanceIdentifier<Node> nodeIid = SouthboundUtils.createInstanceIdentifier(connectionInfo);
Node node = mdsalUtils.read(store, nodeIid);
Assert.assertNotNull(node);
return ovsdbNodeAugmentation;
}
- private OvsdbBridgeAugmentation getBridge(ConnectionInfo connectionInfo) {
+ private static OvsdbBridgeAugmentation getBridge(ConnectionInfo connectionInfo) {
return getBridge(connectionInfo, SouthboundITConstants.BRIDGE_NAME);
}
* @param store defined by the <code>LogicalDatastoreType</code> enumeration
* @return <code>store</code> type data store contents
*/
- private OvsdbBridgeAugmentation getBridge(ConnectionInfo connectionInfo, String bridgeName,
- LogicalDatastoreType store) {
+ private static OvsdbBridgeAugmentation getBridge(ConnectionInfo connectionInfo, String bridgeName,
+ LogicalDatastoreType store) {
Node bridgeNode = getBridgeNode(connectionInfo, bridgeName, store);
Assert.assertNotNull(bridgeNode);
OvsdbBridgeAugmentation ovsdbBridgeAugmentation = bridgeNode.augmentation(OvsdbBridgeAugmentation.class);
* @see SouthboundIT#getBridge(ConnectionInfo, String, LogicalDatastoreType)
* @return <code>LogicalDatastoreType.OPERATIONAL</code> type data store contents
*/
- private OvsdbBridgeAugmentation getBridge(ConnectionInfo connectionInfo, String bridgeName) {
+ private static OvsdbBridgeAugmentation getBridge(ConnectionInfo connectionInfo, String bridgeName) {
return getBridge(connectionInfo, bridgeName, LogicalDatastoreType.OPERATIONAL);
}
* @param store defined by the <code>LogicalDatastoreType</code> enumeration
* @return <code>store</code> type data store contents
*/
- private Node getBridgeNode(ConnectionInfo connectionInfo, String bridgeName, LogicalDatastoreType store) {
+ private static Node getBridgeNode(ConnectionInfo connectionInfo, String bridgeName, LogicalDatastoreType store) {
InstanceIdentifier<Node> bridgeIid =
SouthboundUtils.createInstanceIdentifier(connectionInfo, new OvsdbBridgeName(bridgeName));
return mdsalUtils.read(store, bridgeIid);
* @param bridgeName the bridge name
* @return <code>LogicalDatastoreType.OPERATIONAL</code> type data store contents
*/
- private Node getBridgeNode(ConnectionInfo connectionInfo, String bridgeName) {
+ private static Node getBridgeNode(ConnectionInfo connectionInfo, String bridgeName) {
return getBridgeNode(connectionInfo, bridgeName, LogicalDatastoreType.OPERATIONAL);
}
* @param index the index we're interested in
* @return the augmentation (or {@code null} if none)
*/
- private OvsdbTerminationPointAugmentation getOvsdbTerminationPointAugmentation(
+ private static OvsdbTerminationPointAugmentation getOvsdbTerminationPointAugmentation(
ConnectionInfo connectionInfo, String bridgeName, LogicalDatastoreType store, int index) {
Map<TerminationPointKey, TerminationPoint> tpList = getBridgeNode(connectionInfo, bridgeName, store)
- .nonnullTerminationPoint();
+ .getTerminationPoint();
if (tpList == null) {
return null;
}
*
* @see <code>SouthboundIT.generatePortExternalIdsTestCases()</code> for specific test case information
*/
- private <I extends Identifier<T>, T extends Identifiable<I>> void testCRUDTerminationPoint(
+ private static <I extends Identifier<T>, T extends Identifiable<I>> void testCRUDTerminationPoint(
KeyValueBuilder<T> builder, String prefix, SouthboundTerminationPointHelper<I, T> helper)
throws InterruptedException {
final int terminationPointTestIndex = 0;
}
}
- private List<Set<Integer>> generateVlanSets() {
+ private static List<Set<Integer>> generateVlanSets() {
int min = 0;
int max = 4095;
return Lists.newArrayList(
Sets.newHashSet(min, max, min + 1, max - 1, (max - min) / 2));
}
- private List<Trunks> buildTrunkList(Set<Integer> trunkSet) {
+ private static List<Trunks> buildTrunkList(Set<Integer> trunkSet) {
List<Trunks> trunkList = new ArrayList<>();
for (Integer trunk : trunkSet) {
TrunksBuilder trunkBuilder = new TrunksBuilder();
Map<I, T> readValues(OvsdbBridgeAugmentation augmentation);
}
- private <I extends Identifier<T>, T extends Identifiable<I>> void testCRUDBridge(String prefix,
+ private static <I extends Identifier<T>, T extends Identifiable<I>> void testCRUDBridge(String prefix,
KeyValueBuilder<T> builder, SouthboundBridgeHelper<I, T> helper) throws InterruptedException {
ConnectionInfo connectionInfo = getConnectionInfo(addressStr, portNumber);
// updateFromTestCases represent the original test case value. updateToTestCases represent the new value after
return null;
}
- private <I extends Identifier<T>, T extends Identifiable<I>> void testCRUDQueue(
+ private static <I extends Identifier<T>, T extends Identifiable<I>> void testCRUDQueue(
KeyValueBuilder<T> builder, String prefix, SouthboundQueueHelper<I, T> helper)
throws InterruptedException {
}
- private <I extends Identifier<T>, T extends Identifiable<I>> void testCRUDQos(
+ private static <I extends Identifier<T>, T extends Identifiable<I>> void testCRUDQos(
KeyValueBuilder<T> builder, String prefix, SouthboundQosHelper<I, T> helper)
throws InterruptedException {
Code Review / ovsdb.git / blobdiff