opendaylight/adsal/sal/implementation/src/test/java/org/opendaylight/controller/sal/implementation/ProtocolServiceTest.java

   1 /*
   2  * Copyright (c) 2014 NEC Corporation and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.controller.sal.implementation;
  10
  11 import java.util.HashMap;
  12 import java.util.HashSet;
  13 import java.util.Map;
  14 import java.util.concurrent.ConcurrentHashMap;
  15 import java.util.concurrent.ConcurrentMap;
  16
  17 import org.junit.Test;
  18 import static org.junit.Assert.assertEquals;
  19 import static org.junit.Assert.assertFalse;
  20 import static org.junit.Assert.assertNotNull;
  21 import static org.junit.Assert.assertTrue;
  22
  23 import org.slf4j.Logger;
  24 import org.slf4j.LoggerFactory;
  25
  26 import org.opendaylight.controller.sal.implementation.internal.ProtocolService;
  27 import org.opendaylight.controller.sal.utils.GlobalConstants;
  28
  29 /**
  30  * Unit test for {@link ProtocolService}.
  31  */
  32 public class ProtocolServiceTest {
  33     private static final Logger LOG =
  34         LoggerFactory.getLogger(ProtocolServiceTest.class);
  35
  36     @Test
  37     public void testInstance() {
  38         HashSet<ProtocolService<ITestService>> set = new HashSet<>();
  39         TestService sv1 = new TestService();
  40         HashMap<String, Object> prop1 = new HashMap<>();
  41
  42         ProtocolService<ITestService> ps1 =
  43             new ProtocolService<ITestService>(prop1, sv1);
  44         assertEquals(sv1, ps1.getService());
  45         // Default priority is 0.
  46         assertEquals(0, ps1.getPriority());
  47         assertTrue(set.add(ps1));
  48         assertFalse(set.add(ps1));
  49
  50         // Specify the same service and priority.
  51         String priKey = GlobalConstants.PROTOCOLPLUGINPRIORITY.toString();
  52         prop1.put(priKey, Integer.valueOf(0));
  53         ProtocolService<ITestService> ps2 =
  54             new ProtocolService<ITestService>(prop1, sv1);
  55         assertEquals(sv1, ps2.getService());
  56         assertEquals(0, ps2.getPriority());
  57         assertEquals(ps1, ps2);
  58         assertFalse(set.add(ps1));
  59
  60         // Specify different priority.
  61         prop1.put(priKey, Integer.valueOf(Integer.MAX_VALUE));
  62         ps2 = new ProtocolService<ITestService>(prop1, sv1);
  63         assertEquals(sv1, ps2.getService());
  64         assertEquals(Integer.MAX_VALUE, ps2.getPriority());
  65         assertFalse(ps1.equals(ps2));
  66         assertTrue(set.add(ps2));
  67         assertFalse(set.add(ps2));
  68
  69         // Specify another service.
  70         TestService sv2 = new TestService();
  71         prop1.put(priKey, Integer.valueOf(0));
  72         ps2 = new ProtocolService<ITestService>(prop1, sv2);
  73         assertEquals(sv2, ps2.getService());
  74         assertEquals(0, ps2.getPriority());
  75         assertFalse(ps1.equals(ps2));
  76         assertTrue(set.add(ps2));
  77         assertFalse(set.add(ps2));
  78     }
  79
  80     @Test
  81     public void testSetUnsetError() {
  82         ConcurrentMap<String, ProtocolService<ITestService>> services =
  83             new ConcurrentHashMap<>();
  84         TestService sv = new TestService();
  85         Map<String, Object> props = new HashMap<>();
  86
  87         // null service.
  88         ProtocolService.set(services, props, null, LOG);
  89         assertTrue(services.isEmpty());
  90
  91         ProtocolService.unset(services, props, null, LOG);
  92         assertTrue(services.isEmpty());
  93
  94         // null service property.
  95         ProtocolService.set(services, null, sv, LOG);
  96         assertTrue(services.isEmpty());
  97
  98         ProtocolService.unset(services, null, sv, LOG);
  99         assertTrue(services.isEmpty());
 100
 101         // Type is not specified.
 102         ProtocolService.set(services, props, sv, LOG);
 103         assertTrue(services.isEmpty());
 104
 105         ProtocolService.unset(services, props, sv, LOG);
 106         assertTrue(services.isEmpty());
 107
 108         // null service map.
 109         final String typeKey = GlobalConstants.PROTOCOLPLUGINTYPE.toString();
 110         assertEquals(null, props.put(typeKey, "OF"));
 111         ProtocolService.set(null, props, sv, LOG);
 112         assertTrue(services.isEmpty());
 113
 114         ProtocolService.unset(null, props, sv, LOG);
 115         assertTrue(services.isEmpty());
 116     }
 117
 118     @Test
 119     public void testSetUnset() {
 120         ConcurrentMap<String, ProtocolService<ITestService>> serviceMap =
 121             new ConcurrentHashMap<>();
 122         ConcurrentMap<String, ProtocolService<ITestService>> expected =
 123             new ConcurrentHashMap<>();
 124
 125         final String typeKey = GlobalConstants.PROTOCOLPLUGINTYPE.toString();
 126         final String priKey = GlobalConstants.PROTOCOLPLUGINPRIORITY.toString();
 127         final String[] protocols = {"OF", "PE", "PK"};
 128         final int basePri = 0;
 129         final int loop = 5;
 130
 131         // Should override the service if higher priority is specified.
 132         for (String proto: protocols) {
 133             for (int pri = basePri - loop + 1; pri <= basePri; pri++) {
 134                 TestService sv = new TestService();
 135                 Map<String, Object> props = new HashMap<>();
 136                 assertEquals(null, props.put(typeKey, proto));
 137                 assertEquals(null, props.put(priKey, Integer.valueOf(pri)));
 138                 ProtocolService.set(serviceMap, props, sv, LOG);
 139
 140                 ProtocolService<ITestService> service = serviceMap.get(proto);
 141                 assertNotNull(service);
 142                 assertEquals(sv, service.getService());
 143                 assertEquals(pri, service.getPriority());
 144
 145                 ProtocolService<ITestService> service1 =
 146                     new ProtocolService<ITestService>(props, sv);
 147                 expected.put(proto, service1);
 148                 assertEquals(expected, serviceMap);
 149
 150                 // Unset service request should be ignored if different
 151                 // parameters are specified.
 152                 TestService another = new TestService();
 153                 ProtocolService.unset(serviceMap, props, another, LOG);
 154                 assertEquals(expected, serviceMap);
 155
 156                 props.put(priKey, Integer.valueOf(Integer.MAX_VALUE));
 157                 ProtocolService.unset(serviceMap, props, sv, LOG);
 158                 assertEquals(expected, serviceMap);
 159             }
 160         }
 161
 162         // Should reject the set service request if lower priority is specified.
 163         for (String proto: protocols) {
 164             for (int pri = basePri - loop; pri < basePri; pri++) {
 165                 TestService sv = new TestService();
 166                 Map<String, Object> props = new HashMap<>();
 167                 assertEquals(null, props.put(typeKey, proto));
 168                 assertEquals(null, props.put(priKey, Integer.valueOf(pri)));
 169                 ProtocolService.set(serviceMap, props, sv, LOG);
 170                 assertEquals(expected, serviceMap);
 171             }
 172         }
 173
 174         // Unset protocol services.
 175         for (String proto: protocols) {
 176             ProtocolService<ITestService> service = expected.remove(proto);
 177             assertNotNull(service);
 178
 179             ITestService sv = service.getService();
 180             Map<String, Object> props = new HashMap<>();
 181             assertEquals(null, props.put(typeKey, proto));
 182             assertEquals(null, props.put(priKey, Integer.valueOf(basePri)));
 183             ProtocolService.unset(serviceMap, props, sv, LOG);
 184             assertEquals(expected, serviceMap);
 185
 186             // Should be ignored if the specified service does not exist.
 187             ProtocolService.unset(serviceMap, props, sv, LOG);
 188             assertEquals(expected, serviceMap);
 189         }
 190
 191         assertTrue(serviceMap.isEmpty());
 192     }
 193 }
 194
 195 interface ITestService {
 196 }
 197
 198 class TestService implements ITestService {
 199 }