X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fsal%2Fimplementation%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fsal%2Fimplementation%2FProtocolServiceTest.java;fp=opendaylight%2Fsal%2Fimplementation%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fsal%2Fimplementation%2FProtocolServiceTest.java;h=079350bcc96c6315d73d60313a9a19a67528b2bb;hp=0000000000000000000000000000000000000000;hb=738248cda591e5253e107080ffea1fd4a3e02645;hpb=f4bad4be4f0838122b9799d133878877088e870d diff --git a/opendaylight/sal/implementation/src/test/java/org/opendaylight/controller/sal/implementation/ProtocolServiceTest.java b/opendaylight/sal/implementation/src/test/java/org/opendaylight/controller/sal/implementation/ProtocolServiceTest.java new file mode 100644 index 0000000000..079350bcc9 --- /dev/null +++ b/opendaylight/sal/implementation/src/test/java/org/opendaylight/controller/sal/implementation/ProtocolServiceTest.java @@ -0,0 +1,199 @@ +/* + * Copyright (c) 2014 NEC Corporation and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.controller.sal.implementation; + +import java.util.HashMap; +import java.util.HashSet; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ConcurrentMap; + +import org.junit.Test; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import org.opendaylight.controller.sal.implementation.internal.ProtocolService; +import org.opendaylight.controller.sal.utils.GlobalConstants; + +/** + * Unit test for {@link ProtocolService}. + */ +public class ProtocolServiceTest { + private static final Logger LOG = + LoggerFactory.getLogger(ProtocolServiceTest.class); + + @Test + public void testInstance() { + HashSet> set = new HashSet<>(); + TestService sv1 = new TestService(); + HashMap prop1 = new HashMap<>(); + + ProtocolService ps1 = + new ProtocolService(prop1, sv1); + assertEquals(sv1, ps1.getService()); + // Default priority is 0. + assertEquals(0, ps1.getPriority()); + assertTrue(set.add(ps1)); + assertFalse(set.add(ps1)); + + // Specify the same service and priority. + String priKey = GlobalConstants.PROTOCOLPLUGINPRIORITY.toString(); + prop1.put(priKey, Integer.valueOf(0)); + ProtocolService ps2 = + new ProtocolService(prop1, sv1); + assertEquals(sv1, ps2.getService()); + assertEquals(0, ps2.getPriority()); + assertEquals(ps1, ps2); + assertFalse(set.add(ps1)); + + // Specify different priority. + prop1.put(priKey, Integer.valueOf(Integer.MAX_VALUE)); + ps2 = new ProtocolService(prop1, sv1); + assertEquals(sv1, ps2.getService()); + assertEquals(Integer.MAX_VALUE, ps2.getPriority()); + assertFalse(ps1.equals(ps2)); + assertTrue(set.add(ps2)); + assertFalse(set.add(ps2)); + + // Specify another service. + TestService sv2 = new TestService(); + prop1.put(priKey, Integer.valueOf(0)); + ps2 = new ProtocolService(prop1, sv2); + assertEquals(sv2, ps2.getService()); + assertEquals(0, ps2.getPriority()); + assertFalse(ps1.equals(ps2)); + assertTrue(set.add(ps2)); + assertFalse(set.add(ps2)); + } + + @Test + public void testSetUnsetError() { + ConcurrentMap> services = + new ConcurrentHashMap<>(); + TestService sv = new TestService(); + Map props = new HashMap<>(); + + // null service. + ProtocolService.set(services, props, null, LOG); + assertTrue(services.isEmpty()); + + ProtocolService.unset(services, props, null, LOG); + assertTrue(services.isEmpty()); + + // null service property. + ProtocolService.set(services, null, sv, LOG); + assertTrue(services.isEmpty()); + + ProtocolService.unset(services, null, sv, LOG); + assertTrue(services.isEmpty()); + + // Type is not specified. + ProtocolService.set(services, props, sv, LOG); + assertTrue(services.isEmpty()); + + ProtocolService.unset(services, props, sv, LOG); + assertTrue(services.isEmpty()); + + // null service map. + final String typeKey = GlobalConstants.PROTOCOLPLUGINTYPE.toString(); + assertEquals(null, props.put(typeKey, "OF")); + ProtocolService.set(null, props, sv, LOG); + assertTrue(services.isEmpty()); + + ProtocolService.unset(null, props, sv, LOG); + assertTrue(services.isEmpty()); + } + + @Test + public void testSetUnset() { + ConcurrentMap> serviceMap = + new ConcurrentHashMap<>(); + ConcurrentMap> expected = + new ConcurrentHashMap<>(); + + final String typeKey = GlobalConstants.PROTOCOLPLUGINTYPE.toString(); + final String priKey = GlobalConstants.PROTOCOLPLUGINPRIORITY.toString(); + final String[] protocols = {"OF", "PE", "PK"}; + final int basePri = 0; + final int loop = 5; + + // Should override the service if higher priority is specified. + for (String proto: protocols) { + for (int pri = basePri - loop + 1; pri <= basePri; pri++) { + TestService sv = new TestService(); + Map props = new HashMap<>(); + assertEquals(null, props.put(typeKey, proto)); + assertEquals(null, props.put(priKey, Integer.valueOf(pri))); + ProtocolService.set(serviceMap, props, sv, LOG); + + ProtocolService service = serviceMap.get(proto); + assertNotNull(service); + assertEquals(sv, service.getService()); + assertEquals(pri, service.getPriority()); + + ProtocolService service1 = + new ProtocolService(props, sv); + expected.put(proto, service1); + assertEquals(expected, serviceMap); + + // Unset service request should be ignored if different + // parameters are specified. + TestService another = new TestService(); + ProtocolService.unset(serviceMap, props, another, LOG); + assertEquals(expected, serviceMap); + + props.put(priKey, Integer.valueOf(Integer.MAX_VALUE)); + ProtocolService.unset(serviceMap, props, sv, LOG); + assertEquals(expected, serviceMap); + } + } + + // Should reject the set service request if lower priority is specified. + for (String proto: protocols) { + for (int pri = basePri - loop; pri < basePri; pri++) { + TestService sv = new TestService(); + Map props = new HashMap<>(); + assertEquals(null, props.put(typeKey, proto)); + assertEquals(null, props.put(priKey, Integer.valueOf(pri))); + ProtocolService.set(serviceMap, props, sv, LOG); + assertEquals(expected, serviceMap); + } + } + + // Unset protocol services. + for (String proto: protocols) { + ProtocolService service = expected.remove(proto); + assertNotNull(service); + + ITestService sv = service.getService(); + Map props = new HashMap<>(); + assertEquals(null, props.put(typeKey, proto)); + assertEquals(null, props.put(priKey, Integer.valueOf(basePri))); + ProtocolService.unset(serviceMap, props, sv, LOG); + assertEquals(expected, serviceMap); + + // Should be ignored if the specified service does not exist. + ProtocolService.unset(serviceMap, props, sv, LOG); + assertEquals(expected, serviceMap); + } + + assertTrue(serviceMap.isEmpty()); + } +} + +interface ITestService { +} + +class TestService implements ITestService { +}