opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/sal/binding/test/RuntimeCodeGeneratorTest.java

   1 package org.opendaylight.controller.sal.binding.test;
   2 import static org.junit.Assert.*;
   3
   4 import java.util.Arrays;
   5 import java.util.HashMap;
   6 import java.util.Map;
   7
   8 import javassist.ClassPool;
   9
  10 import org.junit.Before;
  11 import org.junit.Test;
  12 import static org.opendaylight.controller.sal.binding.codegen.RuntimeCodeHelper.*;
  13 import org.opendaylight.controller.sal.binding.codegen.impl.RuntimeCodeGenerator;
  14 import org.opendaylight.controller.sal.binding.test.mock.FooService;
  15 import org.opendaylight.controller.sal.binding.test.mock.ReferencableObject;
  16 import org.opendaylight.controller.sal.binding.test.mock.ReferencableObjectKey;
  17 import org.opendaylight.controller.sal.binding.test.mock.SimpleInput;
  18 import org.opendaylight.yangtools.yang.binding.Augmentation;
  19 import org.opendaylight.yangtools.yang.binding.BaseIdentity;
  20 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  21 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.IdentifiableItem;
  22 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
  23
  24 import static org.mockito.Mockito.*;
  25
  26
  27 public class RuntimeCodeGeneratorTest {
  28
  29     private RuntimeCodeGenerator codeGenerator;
  30
  31
  32     @Before
  33     public void initialize() {
  34         this.codeGenerator = new RuntimeCodeGenerator(ClassPool.getDefault());
  35     }
  36
  37     @Test
  38     public void testGenerateDirectProxy() {
  39         Class<? extends FooService> product = codeGenerator.generateDirectProxy(FooService.class);
  40         assertNotNull(product);
  41     }
  42
  43     @Test
  44     public void testGenerateRouter() throws Exception {
  45         Class<? extends FooService> product = codeGenerator.generateRouter(FooService.class);
  46         assertNotNull(product);
  47         assertNotNull(product.getSimpleName());
  48         assertEquals("2 fields should be generated.",2,product.getFields().length);
  49
  50         verifyRouting(product.newInstance());
  51     }
  52
  53     private void verifyRouting(FooService product) {
  54         Map<InstanceIdentifier,FooService> routingTable = new HashMap<>();
  55         setRoutingTable(product, BaseIdentity.class, routingTable);
  56
  57         assertSame("Returned routing table should be same instance",routingTable,getRoutingTable(product, BaseIdentity.class));
  58
  59         int servicesCount = 2;
  60         int instancesPerService = 3;
  61
  62         InstanceIdentifier[][] identifiers = identifiers(servicesCount,instancesPerService);
  63         FooService service[] = new FooService[] {
  64                 mock(FooService.class, "Instance 0"),
  65                 mock(FooService.class,"Instance 1")
  66         };
  67
  68         for(int i = 0;i<service.length;i++) {
  69             for (InstanceIdentifier instance : identifiers[i]) {
  70                 routingTable.put(instance, service[i]);
  71             }
  72         }
  73
  74         assertEquals("All instances should be registered.", servicesCount*instancesPerService, routingTable.size());
  75
  76         SimpleInput[] instance_0_input = new SimpleInputImpl[] {
  77             new SimpleInputImpl(identifiers[0][0]),
  78             new SimpleInputImpl(identifiers[0][1]),
  79             new SimpleInputImpl(identifiers[0][2])
  80         };
  81
  82         SimpleInput[] instance_1_input = new SimpleInputImpl[] {
  83                 new SimpleInputImpl(identifiers[1][0]),
  84                 new SimpleInputImpl(identifiers[1][1]),
  85                 new SimpleInputImpl(identifiers[1][2])
  86         };
  87
  88         // We test sending mock messages
  89
  90         product.simple(instance_0_input[0]);
  91         verify(service[0]).simple(instance_0_input[0]);
  92
  93         product.simple(instance_0_input[1]);
  94         product.simple(instance_0_input[2]);
  95
  96         verify(service[0]).simple(instance_0_input[1]);
  97         verify(service[0]).simple(instance_0_input[2]);
  98
  99         product.simple(instance_1_input[0]);
 100         verify(service[1]).simple(instance_1_input[0]);
 101     }
 102
 103     private InstanceIdentifier[][] identifiers(int serviceSize, int instancesPerService) {
 104         InstanceIdentifier[][] ret = new InstanceIdentifier[serviceSize][];
 105         int service = 0;
 106         for (int i = 0;i<serviceSize;i++) {
 107
 108             InstanceIdentifier[] instanceIdentifiers = new InstanceIdentifier[instancesPerService];
 109             ret[i] = instanceIdentifiers;
 110             for(int id = 0;id<instancesPerService;id++) {
 111                 instanceIdentifiers[id] = referencableIdentifier(service*instancesPerService+id);
 112             }
 113             service++;
 114         }
 115
 116         return ret;
 117     }
 118
 119     private InstanceIdentifier referencableIdentifier(int i) {
 120         ReferencableObjectKey key = new ReferencableObjectKey(i);
 121         IdentifiableItem<ReferencableObject,ReferencableObjectKey> pathArg = new IdentifiableItem<>(ReferencableObject.class,key);
 122         return new InstanceIdentifier(Arrays.<PathArgument>asList(pathArg), ReferencableObject.class);
 123     }
 124
 125     private static class SimpleInputImpl implements SimpleInput {
 126         private final InstanceIdentifier identifier;
 127
 128         public SimpleInputImpl(InstanceIdentifier _identifier) {
 129             this.identifier = _identifier;
 130         }
 131
 132         @Override
 133         public <E extends Augmentation<SimpleInput>> E getAugmentation(Class<E> augmentationType) {
 134             return null;
 135         }
 136
 137         @Override
 138         public InstanceIdentifier getIdentifier() {
 139             return this.identifier;
 140         }
 141     }
 142 }