groupbasedpolicy/src/test/java/org/opendaylight/groupbasedpolicy/sf/SupportedClassifierDefinitionListenerTest.java

   1 package org.opendaylight.groupbasedpolicy.sf;
   2
   3 import java.util.Collection;
   4 import java.util.List;
   5
   6 import org.junit.Assert;
   7 import org.junit.Before;
   8 import org.junit.Test;
   9 import org.mockito.Mockito;
  10 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  11 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  12 import org.opendaylight.groupbasedpolicy.api.PolicyValidatorRegistry;
  13 import org.opendaylight.groupbasedpolicy.api.sf.EtherTypeClassifierDefinition;
  14 import org.opendaylight.groupbasedpolicy.api.sf.IpProtoClassifierDefinition;
  15 import org.opendaylight.groupbasedpolicy.api.sf.L4ClassifierDefinition;
  16 import org.opendaylight.groupbasedpolicy.test.GbpDataBrokerTest;
  17 import org.opendaylight.groupbasedpolicy.util.IidFactory;
  18 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ParameterName;
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definition.Parameter;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ClassifierDefinition;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ClassifierDefinitionBuilder;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.RendererName;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.SupportedClassifierDefinition;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.SupportedClassifierDefinitionBuilder;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.supported.classifier.definition.SupportedParameterValues;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.supported.classifier.definition.SupportedParameterValuesBuilder;
  27
  28 import com.google.common.base.MoreObjects;
  29 import com.google.common.base.Optional;
  30 import com.google.common.collect.ImmutableList;
  31
  32 public class SupportedClassifierDefinitionListenerTest extends GbpDataBrokerTest {
  33
  34     private SupportedClassifierDefinitionListener listener;
  35     private PolicyValidatorRegistry policyValidatorRegistry;
  36
  37     @Before
  38     public void init() {
  39         policyValidatorRegistry = Mockito.mock(PolicyValidatorRegistry.class);
  40         listener = new SupportedClassifierDefinitionListener(getDataBroker(), policyValidatorRegistry);
  41     }
  42
  43     @Test
  44     public void testSetParentValidators_newValidatorHasParent_parentValidatorExists() {
  45         RendererName rendererFoo = new RendererName("Foo");
  46         SupportedClassifierDefinition supportedIpProtoPort = new SupportedClassifierDefinitionBuilder()
  47             .setClassifierDefinitionId(IpProtoClassifierDefinition.ID).build();
  48         ClassifierInstanceValidator rendererFooIpProtoParentValidator =
  49                 new ClassifierInstanceValidator(supportedIpProtoPort, rendererFoo);
  50         listener.validatorByRendererAndCd.put(rendererFoo, IpProtoClassifierDefinition.ID,
  51                 rendererFooIpProtoParentValidator);
  52         SupportedClassifierDefinition supportedL4SrcPort =
  53                 new SupportedClassifierDefinitionBuilder().setClassifierDefinitionId(L4ClassifierDefinition.ID)
  54                     .setParentClassifierDefinitionId(IpProtoClassifierDefinition.ID)
  55                     .build();
  56         ClassifierInstanceValidator rendererFooL4SrcPortNewValidator =
  57                 new ClassifierInstanceValidator(supportedL4SrcPort, rendererFoo);
  58         listener.validatorByRendererAndCd.put(rendererFoo, L4ClassifierDefinition.ID, rendererFooL4SrcPortNewValidator);
  59         listener.setParentValidators(rendererFooL4SrcPortNewValidator, false);
  60         Assert.assertEquals(rendererFooIpProtoParentValidator, rendererFooL4SrcPortNewValidator.getParentValidator());
  61
  62         listener.setParentValidators(rendererFooL4SrcPortNewValidator, true);
  63         Assert.assertNull(rendererFooIpProtoParentValidator.getParentValidator());
  64     }
  65
  66     @Test
  67     public void testSetParentValidators_newValidatorHasParent_parentValidatorNotExists() {
  68         RendererName rendererFoo = new RendererName("Foo");
  69         SupportedClassifierDefinition supportedL4SrcPort =
  70                 new SupportedClassifierDefinitionBuilder().setClassifierDefinitionId(L4ClassifierDefinition.ID)
  71                     .setParentClassifierDefinitionId(IpProtoClassifierDefinition.ID)
  72                     .build();
  73         ClassifierInstanceValidator rendererFooL4SrcPortNewValidator =
  74                 new ClassifierInstanceValidator(supportedL4SrcPort, rendererFoo);
  75         listener.validatorByRendererAndCd.put(rendererFoo, L4ClassifierDefinition.ID, rendererFooL4SrcPortNewValidator);
  76
  77         listener.setParentValidators(rendererFooL4SrcPortNewValidator, false);
  78         Assert.assertNull(rendererFooL4SrcPortNewValidator.getParentValidator());
  79
  80         SupportedClassifierDefinition supportedIpProtoPort = new SupportedClassifierDefinitionBuilder()
  81             .setClassifierDefinitionId(IpProtoClassifierDefinition.ID).build();
  82         ClassifierInstanceValidator rendererFooIpProtoParentValidator =
  83                 new ClassifierInstanceValidator(supportedIpProtoPort, rendererFoo);
  84         listener.validatorByRendererAndCd.put(rendererFoo, IpProtoClassifierDefinition.ID,
  85                 rendererFooIpProtoParentValidator);
  86
  87         listener.setParentValidators(rendererFooL4SrcPortNewValidator, false);
  88         Assert.assertEquals(rendererFooIpProtoParentValidator, rendererFooL4SrcPortNewValidator.getParentValidator());
  89
  90         listener.setParentValidators(rendererFooL4SrcPortNewValidator, true);
  91         Assert.assertNull(rendererFooIpProtoParentValidator.getParentValidator());
  92     }
  93
  94     @Test
  95     public void testGetValidatorsWithParentCdForRenderer() {
  96         List<SupportedParameterValues> srcPortParam = ImmutableList.of(new SupportedParameterValuesBuilder()
  97             .setParameterName(new ParameterName(L4ClassifierDefinition.SRC_PORT_PARAM)).build());
  98         SupportedClassifierDefinition supportedL4SrcPort =
  99                 new SupportedClassifierDefinitionBuilder().setClassifierDefinitionId(L4ClassifierDefinition.ID)
 100                     .setParentClassifierDefinitionId(IpProtoClassifierDefinition.ID)
 101                     .setSupportedParameterValues(srcPortParam)
 102                     .build();
 103         RendererName rendererFoo = new RendererName("Foo");
 104         ClassifierInstanceValidator rendererFooL4SrcPortValidator =
 105                 new ClassifierInstanceValidator(supportedL4SrcPort, rendererFoo);
 106         listener.validatorByRendererAndCd.put(rendererFoo, supportedL4SrcPort.getClassifierDefinitionId(),
 107                 rendererFooL4SrcPortValidator);
 108         List<SupportedParameterValues> dstPortParam = ImmutableList.of(new SupportedParameterValuesBuilder()
 109             .setParameterName(new ParameterName(L4ClassifierDefinition.DST_PORT_PARAM)).build());
 110         SupportedClassifierDefinition supportedL4DstPort =
 111                 new SupportedClassifierDefinitionBuilder().setClassifierDefinitionId(L4ClassifierDefinition.ID)
 112                     .setParentClassifierDefinitionId(IpProtoClassifierDefinition.ID)
 113                     .setSupportedParameterValues(dstPortParam)
 114                     .build();
 115         RendererName rendererBar = new RendererName("Bar");
 116         ClassifierInstanceValidator rendererBarL4DstPortValidator =
 117                 new ClassifierInstanceValidator(supportedL4DstPort, rendererBar);
 118         listener.validatorByRendererAndCd.put(rendererBar, supportedL4DstPort.getClassifierDefinitionId(),
 119                 rendererBarL4DstPortValidator);
 120
 121         Collection<ClassifierInstanceValidator> validatorsWithParentIpProtoCdForRendererFoo =
 122                 listener.getValidatorsWithParentCdForRenderer(IpProtoClassifierDefinition.ID, rendererFoo);
 123         Assert.assertNotNull(validatorsWithParentIpProtoCdForRendererFoo);
 124         Assert.assertEquals(validatorsWithParentIpProtoCdForRendererFoo.size(), 1);
 125         Assert.assertTrue(validatorsWithParentIpProtoCdForRendererFoo.contains(rendererFooL4SrcPortValidator));
 126     }
 127
 128     @Test
 129     public void testGetAllSupportedParams() {
 130         List<SupportedParameterValues> srcPortParam = ImmutableList.of(new SupportedParameterValuesBuilder()
 131             .setParameterName(new ParameterName(L4ClassifierDefinition.SRC_PORT_PARAM)).build());
 132         SupportedClassifierDefinition supportedL4SrcPort = new SupportedClassifierDefinitionBuilder()
 133             .setClassifierDefinitionId(L4ClassifierDefinition.ID).setSupportedParameterValues(srcPortParam).build();
 134         RendererName rendererFoo = new RendererName("Foo");
 135         listener.validatorByRendererAndCd.put(rendererFoo, supportedL4SrcPort.getClassifierDefinitionId(),
 136                 new ClassifierInstanceValidator(supportedL4SrcPort, rendererFoo));
 137         List<SupportedParameterValues> dstPortParam = ImmutableList.of(new SupportedParameterValuesBuilder()
 138             .setParameterName(new ParameterName(L4ClassifierDefinition.DST_PORT_PARAM)).build());
 139         SupportedClassifierDefinition supportedL4DstPort = new SupportedClassifierDefinitionBuilder()
 140             .setClassifierDefinitionId(L4ClassifierDefinition.ID).setSupportedParameterValues(dstPortParam).build();
 141         RendererName rendererBar = new RendererName("Bar");
 142         listener.validatorByRendererAndCd.put(rendererBar, supportedL4DstPort.getClassifierDefinitionId(),
 143                 new ClassifierInstanceValidator(supportedL4DstPort, rendererBar));
 144
 145         List<ParameterName> allSupportedParams = listener.getAllSupportedParams(L4ClassifierDefinition.ID);
 146         Assert.assertTrue(allSupportedParams.contains(new ParameterName(L4ClassifierDefinition.SRC_PORT_PARAM)));
 147         Assert.assertTrue(allSupportedParams.contains(new ParameterName(L4ClassifierDefinition.DST_PORT_PARAM)));
 148     }
 149
 150     @Test
 151     public void testCreateClassifierDefinitionWithUnionOfParams_allSupportedParams() {
 152         List<ParameterName> supportedParams =
 153                 ImmutableList.of(new ParameterName(EtherTypeClassifierDefinition.ETHERTYPE_PARAM));
 154         ClassifierDefinition classifierDefinitionWithUnionOfParams = listener
 155             .createClassifierDefinitionWithUnionOfParams(EtherTypeClassifierDefinition.DEFINITION, supportedParams);
 156         assertEquals(EtherTypeClassifierDefinition.DEFINITION, classifierDefinitionWithUnionOfParams);
 157     }
 158
 159     @Test
 160     public void testCreateClassifierDefinitionWithUnionOfParams_emptySupportedParams() {
 161         List<ParameterName> supportedParams = ImmutableList.of();
 162         ClassifierDefinition classifierDefinitionWithUnionOfParams = listener
 163             .createClassifierDefinitionWithUnionOfParams(EtherTypeClassifierDefinition.DEFINITION, supportedParams);
 164         Assert.assertNull(classifierDefinitionWithUnionOfParams);
 165     }
 166
 167     @Test
 168     public void testCreateClassifierDefinitionWithUnionOfParams_someSupportedParams() {
 169         ImmutableList<ParameterName> supportedParams =
 170                 ImmutableList.of(new ParameterName(L4ClassifierDefinition.DST_PORT_PARAM),
 171                         new ParameterName(L4ClassifierDefinition.DST_PORT_RANGE_PARAM));
 172         ClassifierDefinition classifierDefinitionWithUnionOfParams = listener
 173             .createClassifierDefinitionWithUnionOfParams(L4ClassifierDefinition.DEFINITION, supportedParams);
 174         ClassifierDefinition expectedCd = new ClassifierDefinitionBuilder(L4ClassifierDefinition.DEFINITION)
 175             .setParameter(ImmutableList.<Parameter>of(
 176                     getParameterFromDefinition(L4ClassifierDefinition.DEFINITION,
 177                             L4ClassifierDefinition.DST_PORT_PARAM),
 178                     getParameterFromDefinition(L4ClassifierDefinition.DEFINITION,
 179                             L4ClassifierDefinition.DST_PORT_RANGE_PARAM)))
 180             .build();
 181         assertEquals(expectedCd, classifierDefinitionWithUnionOfParams);
 182     }
 183
 184     @Test
 185     public void testPutOrRemoveClassifierDefinitionInOperDs_cdIsInConfDs_withSupportedParams() throws Exception {
 186         WriteTransaction wTx = getDataBroker().newWriteOnlyTransaction();
 187         wTx.put(LogicalDatastoreType.CONFIGURATION,
 188                 IidFactory.classifierDefinitionIid(EtherTypeClassifierDefinition.ID),
 189                 EtherTypeClassifierDefinition.DEFINITION, true);
 190         wTx.submit().get();
 191         List<ParameterName> supportedParams =
 192                 ImmutableList.of(new ParameterName(EtherTypeClassifierDefinition.ETHERTYPE_PARAM));
 193
 194         listener.putOrRemoveClassifierDefinitionInOperDs(EtherTypeClassifierDefinition.ID, supportedParams);
 195         Optional<ClassifierDefinition> potentialCd = getDataBroker().newReadOnlyTransaction()
 196             .read(LogicalDatastoreType.OPERATIONAL,
 197                     IidFactory.classifierDefinitionIid(EtherTypeClassifierDefinition.ID))
 198             .get();
 199         Assert.assertTrue(potentialCd.isPresent());
 200         assertEquals(EtherTypeClassifierDefinition.DEFINITION, potentialCd.get());
 201     }
 202
 203     @Test
 204     public void testPutOrRemoveClassifierDefinitionInOperDs_cdIsNotInConfDs_withSupportedParams() throws Exception {
 205         List<ParameterName> supportedParams =
 206                 ImmutableList.of(new ParameterName(EtherTypeClassifierDefinition.ETHERTYPE_PARAM));
 207
 208         listener.putOrRemoveClassifierDefinitionInOperDs(EtherTypeClassifierDefinition.ID, supportedParams);
 209         Optional<ClassifierDefinition> potentialCd = getDataBroker().newReadOnlyTransaction()
 210             .read(LogicalDatastoreType.OPERATIONAL,
 211                     IidFactory.classifierDefinitionIid(EtherTypeClassifierDefinition.ID))
 212             .get();
 213         Assert.assertFalse(potentialCd.isPresent());
 214     }
 215
 216     @Test
 217     public void testPutOrRemoveClassifierDefinitionInOperDs_cdIsInConfDs_emptySupportedParams() throws Exception {
 218         WriteTransaction wTx = getDataBroker().newWriteOnlyTransaction();
 219         wTx.put(LogicalDatastoreType.CONFIGURATION,
 220                 IidFactory.classifierDefinitionIid(EtherTypeClassifierDefinition.ID),
 221                 EtherTypeClassifierDefinition.DEFINITION, true);
 222         wTx.put(LogicalDatastoreType.OPERATIONAL, IidFactory.classifierDefinitionIid(EtherTypeClassifierDefinition.ID),
 223                 EtherTypeClassifierDefinition.DEFINITION, true);
 224         wTx.submit().get();
 225         List<ParameterName> supportedParams = ImmutableList.of();
 226
 227         listener.putOrRemoveClassifierDefinitionInOperDs(EtherTypeClassifierDefinition.ID, supportedParams);
 228         Optional<ClassifierDefinition> potentialCd = getDataBroker().newReadOnlyTransaction()
 229             .read(LogicalDatastoreType.OPERATIONAL,
 230                     IidFactory.classifierDefinitionIid(EtherTypeClassifierDefinition.ID))
 231             .get();
 232         Assert.assertFalse(potentialCd.isPresent());
 233     }
 234
 235     @Test
 236     public void testPutOrRemoveClassifierDefinitionInOperDs_cdIsInConfDs_changedSupportedParams() throws Exception {
 237         WriteTransaction wTx = getDataBroker().newWriteOnlyTransaction();
 238         wTx.put(LogicalDatastoreType.CONFIGURATION, IidFactory.classifierDefinitionIid(L4ClassifierDefinition.ID),
 239                 L4ClassifierDefinition.DEFINITION, true);
 240         wTx.put(LogicalDatastoreType.OPERATIONAL, IidFactory.classifierDefinitionIid(L4ClassifierDefinition.ID),
 241                 L4ClassifierDefinition.DEFINITION, true);
 242         wTx.submit().get();
 243         ImmutableList<ParameterName> supportedParams =
 244                 ImmutableList.of(new ParameterName(L4ClassifierDefinition.DST_PORT_PARAM),
 245                         new ParameterName(L4ClassifierDefinition.DST_PORT_RANGE_PARAM));
 246
 247         listener.putOrRemoveClassifierDefinitionInOperDs(L4ClassifierDefinition.ID, supportedParams);
 248         Optional<ClassifierDefinition> potentialCd = getDataBroker().newReadOnlyTransaction()
 249             .read(LogicalDatastoreType.OPERATIONAL, IidFactory.classifierDefinitionIid(L4ClassifierDefinition.ID))
 250             .get();
 251         ClassifierDefinition expectedCd = new ClassifierDefinitionBuilder(L4ClassifierDefinition.DEFINITION)
 252             .setParameter(ImmutableList.<Parameter>of(
 253                     getParameterFromDefinition(L4ClassifierDefinition.DEFINITION,
 254                             L4ClassifierDefinition.DST_PORT_PARAM),
 255                     getParameterFromDefinition(L4ClassifierDefinition.DEFINITION,
 256                             L4ClassifierDefinition.DST_PORT_RANGE_PARAM)))
 257             .build();
 258         Assert.assertTrue(potentialCd.isPresent());
 259         assertEquals(expectedCd, potentialCd.get());
 260     }
 261
 262     private void assertEquals(ClassifierDefinition expectedCd, ClassifierDefinition actualCd) {
 263         Assert.assertEquals(expectedCd.getId(), actualCd.getId());
 264         Assert.assertEquals(expectedCd.getName(), actualCd.getName());
 265         Assert.assertEquals(expectedCd.getDescription(), actualCd.getDescription());
 266         Assert.assertEquals(expectedCd.getFallbackBehavior(), actualCd.getFallbackBehavior());
 267         List<Parameter> expectedParams = getNonNullList(expectedCd.getParameter());
 268         List<Parameter> actualParams = getNonNullList(actualCd.getParameter());
 269         Assert.assertTrue(expectedParams.containsAll(actualParams) && actualParams.containsAll(expectedParams));
 270     }
 271
 272     private <T> List<T> getNonNullList(List<T> list) {
 273         return MoreObjects.firstNonNull(list, ImmutableList.<T>of());
 274     }
 275
 276     // @Test
 277     // public void testCreateClassifierDefinitionWithUnionOfParams_allParamsSupportedByRenderer()
 278     // throws Exception {
 279     // WriteTransaction wTx = getDataBroker().newWriteOnlyTransaction();
 280     // wTx.put(LogicalDatastoreType.CONFIGURATION,
 281     // IidFactory.classifierDefinitionIid(EtherTypeClassifierDefinition.ID),
 282     // EtherTypeClassifierDefinition.DEFINITION, true);
 283     // wTx.submit().get();
 284     //
 285     // SupportedClassifierDefinition supportedClassifierDefinition = new
 286     // SupportedClassifierDefinitionBuilder()
 287     // .setClassifierDefinitionId(EtherTypeClassifierDefinition.ID)
 288     // .setSupportedParameterValues(
 289     // ImmutableList.<SupportedParameterValues>of(new SupportedParameterValuesBuilder()
 290     // .setParameterName(new ParameterName(EtherTypeClassifierDefinition.ETHERTYPE_PARAM)).build()))
 291     // .build();
 292     // Renderer renderer = createRenderer("renderer1");
 293     // registerSupportedClassifierDefByRenderer(supportedClassifierDefinition, renderer);
 294     //
 295     // ClassifierDefinition newCd = listener.createClassifierDefinitionWithUnionOfParams(
 296     // EtherTypeClassifierDefinition.ID, getDataBroker().newReadOnlyTransaction());
 297     // Assert.assertEquals(EtherTypeClassifierDefinition.DEFINITION, newCd);
 298     // }
 299
 300     // @Test
 301     // public void testCreateClassifierDefinitionWithUnionOfParams_someParamsSupportedByRenderer()
 302     // throws Exception {
 303     // WriteTransaction wTx = getDataBroker().newWriteOnlyTransaction();
 304     // wTx.put(LogicalDatastoreType.CONFIGURATION,
 305     // IidFactory.classifierDefinitionIid(L4ClassifierDefinition.ID),
 306     // L4ClassifierDefinition.DEFINITION, true);
 307     // wTx.submit().get();
 308     //
 309     // SupportedClassifierDefinition supportedClassifierDefinition = new
 310     // SupportedClassifierDefinitionBuilder()
 311     // .setClassifierDefinitionId(L4ClassifierDefinition.ID)
 312     // .setSupportedParameterValues(
 313     // ImmutableList.<SupportedParameterValues>of(new SupportedParameterValuesBuilder()
 314     // .setParameterName(new ParameterName(L4ClassifierDefinition.DST_PORT_PARAM)).build()))
 315     // .build();
 316     // Renderer renderer = createRenderer("renderer1");
 317     // registerSupportedClassifierDefByRenderer(supportedClassifierDefinition, renderer);
 318     //
 319     // ClassifierDefinition newCd =
 320     // listener.createClassifierDefinitionWithUnionOfParams(L4ClassifierDefinition.ID,
 321     // getDataBroker().newReadOnlyTransaction());
 322     // ClassifierDefinition expectedCd = new
 323     // ClassifierDefinitionBuilder(L4ClassifierDefinition.DEFINITION)
 324     // .setParameter(ImmutableList.<Parameter>of(getParameterFromDefinition(L4ClassifierDefinition.DEFINITION,
 325     // L4ClassifierDefinition.DST_PORT_PARAM)))
 326     // .build();
 327     // Assert.assertEquals(expectedCd, newCd);
 328     // }
 329     //
 330     // private Renderer createRenderer(String rendererName) {
 331     // return new RendererBuilder().setName(new RendererName(rendererName)).build();
 332     // }
 333     //
 334     private Parameter getParameterFromDefinition(ClassifierDefinition cd, String parameter) {
 335         for (Parameter param : cd.getParameter()) {
 336             if (param.getName().getValue().equals(parameter)) {
 337                 return param;
 338             }
 339         }
 340         throw new IllegalArgumentException("Parameter " + parameter + " is not located in " + cd);
 341     }
 342     //
 343     // private void registerSupportedClassifierDefByRenderer(SupportedClassifierDefinition
 344     // supportedClassifierDefinition,
 345     // Renderer renderer) {
 346     // InstanceIdentifier<SupportedClassifierDefinition> scdIid =
 347     // InstanceIdentifier.builder(Renderers.class)
 348     // .child(Renderer.class, renderer.getKey())
 349     // .child(Capabilities.class)
 350     // .child(SupportedClassifierDefinition.class, supportedClassifierDefinition.getKey())
 351     // .build();
 352     // listener.ciValidatorBySupportedCdKey.put(new SupportedCdKey(scdIid, null),
 353     // new ClassifierInstanceValidator(supportedClassifierDefinition));
 354     // listener.supportedCdIidByCdId.put(supportedClassifierDefinition.getClassifierDefinitionId(),
 355     // scdIid);
 356     // }
 357
 358 }