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

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