binding2/mdsal-binding2-generator-impl/src/test/java/org/opendaylight/mdsal/binding/javav2/generator/impl/AugmentToGenTypeTest.java

   1 /*
   2  * Copyright (c) 2017 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.mdsal.binding.javav2.generator.impl;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertNotNull;
  12 import static org.junit.Assert.assertTrue;
  13 import static org.junit.Assert.fail;
  14 import static org.mockito.Mockito.mock;
  15 import static org.mockito.Mockito.when;
  16
  17 import java.lang.reflect.Constructor;
  18 import java.util.ArrayList;
  19 import java.util.Collection;
  20 import java.util.HashMap;
  21 import java.util.HashSet;
  22 import java.util.List;
  23 import java.util.Map;
  24 import java.util.Optional;
  25 import java.util.Set;
  26 import org.junit.Test;
  27 import org.opendaylight.mdsal.binding.javav2.generator.context.ModuleContext;
  28 import org.opendaylight.mdsal.binding.javav2.generator.spi.TypeProvider;
  29 import org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.builder.GeneratedTypeBuilderImpl;
  30 import org.opendaylight.mdsal.binding.javav2.generator.yang.types.TypeProviderImpl;
  31 import org.opendaylight.mdsal.binding.javav2.model.api.GeneratedType;
  32 import org.opendaylight.mdsal.binding.javav2.model.api.Type;
  33 import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedTypeBuilder;
  34 import org.opendaylight.mdsal.binding.javav2.spec.runtime.BindingNamespaceType;
  35 import org.opendaylight.mdsal.binding.javav2.spec.structural.Augmentable;
  36 import org.opendaylight.yangtools.yang.common.QName;
  37 import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
  38 import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
  39 import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
  40 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
  41 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  42 import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode;
  43 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
  44 import org.opendaylight.yangtools.yang.model.api.Module;
  45 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  46 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
  47 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  48 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
  49 import org.opendaylight.yangtools.yang.model.api.UsesNode;
  50 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
  51
  52 public class AugmentToGenTypeTest {
  53
  54     @Test(expected = UnsupportedOperationException.class)
  55     public void constructorTest() throws Throwable {
  56         final Constructor<AugmentToGenType> constructor = AugmentToGenType.class.getDeclaredConstructor();
  57         constructor.setAccessible(true);
  58         final Object[] objs = {};
  59         try {
  60             constructor.newInstance(objs);
  61         } catch (final Exception e) {
  62             throw e.getCause();
  63         }
  64     }
  65
  66     @Test
  67     public void generateNullModuleTest() {
  68         final SchemaContext context = null;
  69         final TypeProvider typeProvider = null;
  70         final Map<Module, ModuleContext> genCtx = new HashMap<>();
  71         final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders = new HashMap<>();
  72         final Module m = null;
  73
  74         try {
  75             AugmentToGenType.generate(m, context, typeProvider, genCtx, genTypeBuilders, false);
  76             fail();
  77         } catch (final IllegalArgumentException e) {
  78             assertEquals("Module reference cannot be NULL.", e.getMessage());
  79         }
  80     }
  81
  82     @Test
  83     public void generateNullModuleNameTest() {
  84         final SchemaContext context = null;
  85         final TypeProvider typeProvider = null;
  86         final Map<Module, ModuleContext> genCtx = new HashMap<>();
  87         final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders = new HashMap<>();
  88         final Module m = mock(Module.class);
  89         when(m.getName()).thenReturn(null);
  90
  91         try {
  92             AugmentToGenType.generate(m, context, typeProvider, genCtx, genTypeBuilders, false);
  93             fail();
  94         } catch (final IllegalArgumentException e) {
  95             assertEquals("Module name cannot be NULL.", e.getMessage());
  96         }
  97     }
  98
  99     @Test
 100     public void generateNullModuleAugmentationsTest() {
 101         final SchemaContext context = null;
 102         final TypeProvider typeProvider = null;
 103         final Map<Module, ModuleContext> genCtx = new HashMap<>();
 104         final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders = new HashMap<>();
 105         final Module m = mock(Module.class);
 106         when(m.getName()).thenReturn("name");
 107         when(m.getAugmentations()).thenReturn(null);
 108
 109         try {
 110             AugmentToGenType.generate(m, context, typeProvider, genCtx, genTypeBuilders, false);
 111             fail();
 112         } catch (final IllegalStateException e) {
 113             assertEquals("Augmentations Set cannot be NULL.", e.getMessage());
 114         }
 115     }
 116
 117     @Test
 118     public void generateWithoutAugmentationsTest() {
 119         final SchemaContext context = YangParserTestUtils.parseYangResource("/generator/test.yang");
 120         final TypeProvider typeProvider = new TypeProviderImpl(context);
 121         final Map<Module, ModuleContext> genCtx = new HashMap<>();
 122         final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders = new HashMap<>();
 123         final Map<Module, ModuleContext> invoke = AugmentToGenType.generate(context.getModules().iterator().next(),
 124             context, typeProvider, genCtx, genTypeBuilders, false);
 125         assertNotNull(invoke);
 126     }
 127
 128     @Test
 129     public void generateWithAugmentationsTest() {
 130         final SchemaContext context = YangParserTestUtils.parseYangResource("/generator/test-augment.yang");
 131         final TypeProvider typeProvider = new TypeProviderImpl(context);
 132         final Map<Module, ModuleContext> genCtx = mock(Map.class);
 133         final Collection<ModuleContext> moduleContexts = new ArrayList<>();
 134         final ModuleContext moduleContext = new ModuleContext();
 135         moduleContexts.add(moduleContext);
 136         final QName create = QName.create("urn:test:simple:test", "2017-02-06", "my-cont");
 137         final SchemaNode schemaNode = mock(SchemaNode.class);
 138         when(schemaNode.getPath()).thenReturn(SchemaPath.create(true, create));
 139         moduleContext.addChildNodeType(schemaNode, new GeneratedTypeBuilderImpl("test", "Test", moduleContext));
 140         when(genCtx.values()).thenReturn(moduleContexts);
 141         when(genCtx.get(context.getModules().iterator().next())).thenReturn(moduleContext);
 142         final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders = new HashMap<>();
 143
 144         final Map<Module, ModuleContext> invoke = AugmentToGenType.generate(context.getModules().iterator().next(),
 145             context, typeProvider, genCtx, genTypeBuilders, false);
 146         assertNotNull(invoke);
 147     }
 148
 149     @Test
 150     public void resolveAugmentationsNullModuleTest() {
 151         try {
 152             AugmentToGenType.resolveAugmentations(null, null);
 153             fail();
 154         } catch (final IllegalArgumentException e) {
 155             assertEquals("Module reference cannot be NULL.", e.getMessage());
 156         }
 157     }
 158
 159     @Test
 160     public void resolveAugmentationsNullAugmentationsTest() {
 161         final Module m = mock(Module.class);
 162         when(m.getAugmentations()).thenReturn(null);
 163         final SchemaContext schemaContext = mock(SchemaContext.class);
 164
 165         try {
 166             AugmentToGenType.resolveAugmentations(m, schemaContext);
 167             fail();
 168         } catch (final IllegalStateException e) {
 169             assertEquals("Augmentations Set cannot be NULL.", e.getMessage());
 170         }
 171     }
 172
 173     @Test
 174     public void resolveAugmentationsTest() {
 175         final Module m = mock(Module.class);
 176         final Module m2 = mock(Module.class);
 177         final SchemaContext schemaContext = mock(SchemaContext.class);
 178
 179         final Set<AugmentationSchemaNode> augmentations = new HashSet<>();
 180
 181         final QName q1 = QName.create("q1", "2017-04-04", "q1");
 182         final QName q2 = QName.create("q2", "2017-04-04", "q2");
 183         final QName q3 = QName.create("q3", "2017-04-04", "q3");
 184         final QName q4 = QName.create("q4", "2017-04-04", "q4");
 185         final QName q5 = QName.create("q5", "2017-04-04", "q5");
 186
 187         final AugmentationSchemaNode AugmentationSchemaNode1 = mock(AugmentationSchemaNode.class);
 188         when(AugmentationSchemaNode1.getTargetPath()).thenReturn(SchemaPath.create(true, q1, q2));
 189         final AugmentationSchemaNode AugmentationSchemaNode2 = mock(AugmentationSchemaNode.class);
 190         when(AugmentationSchemaNode2.getTargetPath()).thenReturn(SchemaPath.create(true, q3, q4, q5));
 191         augmentations.add(AugmentationSchemaNode1);
 192         augmentations.add(AugmentationSchemaNode2);
 193
 194         when(m.getAugmentations()).thenReturn(augmentations);
 195         when(schemaContext.findModule(q1.getModule())).thenReturn(Optional.of(m2));
 196         when(schemaContext.findModule(q3.getModule())).thenReturn(Optional.of(m2));
 197
 198         final List<AugmentationSchemaNode> result = AugmentToGenType.resolveAugmentations(m, schemaContext);
 199         assertNotNull(result);
 200         assertTrue(!result.isEmpty());
 201         assertEquals(result.get(0), AugmentationSchemaNode1);
 202         assertEquals(result.get(1), AugmentationSchemaNode2);
 203     }
 204
 205     @Test
 206     public void augmentationToGenTypesNullPckgNameTest() {
 207         final String augmPackName = null;
 208         final Map.Entry<SchemaPath, List<AugmentationSchemaNode>> schemaPathAugmentListEntry = null;
 209         final SchemaContext context = null;
 210         final TypeProvider typeProvider = null;
 211         final Map<Module, ModuleContext> genCtx = new HashMap<>();
 212         final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders = new HashMap<>();
 213         final Module m = null;
 214
 215         try {
 216             AugmentToGenType.augmentationToGenTypes(augmPackName, schemaPathAugmentListEntry, m, context, false, genCtx,
 217                 genTypeBuilders, typeProvider);
 218             fail();
 219         } catch (final IllegalArgumentException e) {
 220             assertEquals("Package Name cannot be NULL.", e.getMessage());
 221         }
 222     }
 223
 224     @Test
 225     public void augmentationToGenTypesNullAugSchemaTest() {
 226         final String augmPackName = "pckg.name";
 227         final Map.Entry<SchemaPath, List<AugmentationSchemaNode>> schemaPathAugmentListEntry = null;
 228         final SchemaContext context = null;
 229         final TypeProvider typeProvider = null;
 230         final Map<Module, ModuleContext> genCtx = new HashMap<>();
 231         final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders = new HashMap<>();
 232         final Module m = null;
 233
 234         try {
 235             AugmentToGenType.augmentationToGenTypes(augmPackName, schemaPathAugmentListEntry, m, context, false, genCtx,
 236                 genTypeBuilders, typeProvider);
 237             fail();
 238         } catch (final IllegalArgumentException e) {
 239             assertEquals("Augmentation List Entry cannot be NULL.", e.getMessage());
 240         }
 241     }
 242
 243     @Test
 244     public void augmentationToGenTypesNullAugSchemaTargetPathTest() {
 245         final String augmPackName = "pckg.name";
 246         final AugmentationSchemaNode augmSchema = mock(AugmentationSchemaNode.class);
 247         when(augmSchema.getTargetPath()).thenReturn(null);
 248
 249         final List<AugmentationSchemaNode> AugmentationSchemaNodeList = new ArrayList<>();
 250         final Map.Entry<SchemaPath, List<AugmentationSchemaNode>> schemaPathAugmentListEntry = mock(Map.Entry.class);
 251         when(schemaPathAugmentListEntry.getKey()).thenReturn(null);
 252         when(schemaPathAugmentListEntry.getValue()).thenReturn(AugmentationSchemaNodeList);
 253
 254         final SchemaContext context = null;
 255         final TypeProvider typeProvider = null;
 256         final Map<Module, ModuleContext> genCtx = new HashMap<>();
 257         final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders = new HashMap<>();
 258         final Module m = null;
 259
 260         try {
 261             AugmentToGenType.augmentationToGenTypes(augmPackName, schemaPathAugmentListEntry, m, context, false, genCtx,
 262                 genTypeBuilders, typeProvider);
 263             fail();
 264         } catch (final IllegalStateException e) {
 265             assertEquals("Augmentation List Entry does not contain Target Path (Target Path is NULL).", e.getMessage());
 266         }
 267     }
 268
 269     @Test
 270     public void augmentationToGenTypesNullAugSchemaListTest() {
 271         final String augmPackName = "pckg.name";
 272         final AugmentationSchemaNode augmSchema = mock(AugmentationSchemaNode.class);
 273         final QName qnamePath = QName.create("test", "2017-04-04", "aug");
 274         final SchemaPath path = SchemaPath.create(true, qnamePath);
 275         when(augmSchema.getTargetPath()).thenReturn(path);
 276
 277         final List<AugmentationSchemaNode> AugmentationSchemaNodeList = new ArrayList<>();
 278         final Map.Entry<SchemaPath, List<AugmentationSchemaNode>> schemaPathAugmentListEntry = mock(Map.Entry.class);
 279         when(schemaPathAugmentListEntry.getKey()).thenReturn(path);
 280         when(schemaPathAugmentListEntry.getValue()).thenReturn(AugmentationSchemaNodeList);
 281
 282         final SchemaContext context = null;
 283         final TypeProvider typeProvider = null;
 284         final Map<Module, ModuleContext> genCtx = new HashMap<>();
 285         final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders = new HashMap<>();
 286         final Module m = null;
 287
 288         try {
 289             AugmentToGenType.augmentationToGenTypes(augmPackName, schemaPathAugmentListEntry, m, context, false, genCtx,
 290                 genTypeBuilders, typeProvider);
 291             fail();
 292         } catch (final IllegalStateException e) {
 293             assertEquals("Augmentation List cannot be empty.", e.getMessage());
 294         }
 295     }
 296
 297     @Test
 298     public void augmentationToGenTypesNullAugSchemaTargetNodeTest() {
 299         final String augmPackName = "pckg.name";
 300
 301         final AugmentationSchemaNode augmSchema = mock(AugmentationSchemaNode.class);
 302         final QName qnamePath = QName.create("test", "2017-04-04", "aug");
 303         final SchemaPath path = SchemaPath.create(true, qnamePath);
 304         when(augmSchema.getTargetPath()).thenReturn(path);
 305         final Set<UsesNode> uses = new HashSet<>();
 306         when(augmSchema.getUses()).thenReturn(uses);
 307
 308         final List<AugmentationSchemaNode> AugmentationSchemaNodeList = new ArrayList<>();
 309         AugmentationSchemaNodeList.add(augmSchema);
 310         final Map.Entry<SchemaPath, List<AugmentationSchemaNode>> schemaPathAugmentListEntry = mock(Map.Entry.class);
 311         when(schemaPathAugmentListEntry.getKey()).thenReturn(path);
 312         when(schemaPathAugmentListEntry.getValue()).thenReturn(AugmentationSchemaNodeList);
 313
 314         final SchemaContext context = mock(SchemaContext.class);
 315         final Module moduleAug = mock(Module.class);
 316         final DataSchemaNode schNode = null;
 317         when(moduleAug.getDataChildByName(qnamePath)).thenReturn(schNode);
 318         when(context.findModule(qnamePath.getModule())).thenReturn(Optional.of(moduleAug));
 319
 320         final TypeProvider typeProvider = null;
 321         final Map<Module, ModuleContext> genCtx = new HashMap<>();
 322         final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders = new HashMap<>();
 323
 324         final Module m = mock(Module.class);
 325         when(m.getName()).thenReturn("augm-module");
 326         when(m.getNamespace()).thenReturn(qnamePath.getNamespace());
 327         when(m.getRevision()).thenReturn(qnamePath.getRevision());
 328
 329         try {
 330             AugmentToGenType.augmentationToGenTypes(augmPackName, schemaPathAugmentListEntry, m, context, false, genCtx,
 331                 genTypeBuilders, typeProvider);
 332             fail();
 333         } catch (final IllegalArgumentException e) {
 334             assertEquals("augment target not found: " + path, e.getMessage());
 335         }
 336     }
 337
 338     @Test
 339     public void augmentationToGenTypesNullAugTargetGTBTest() {
 340         final String augmPackName = "pckg.name";
 341
 342         final AugmentationSchemaNode augmSchema = mock(AugmentationSchemaNode.class);
 343         final QName qnamePath = QName.create("test", "2017-04-04", "aug");
 344         final SchemaPath path = SchemaPath.create(true, qnamePath);
 345         when(augmSchema.getTargetPath()).thenReturn(path);
 346         final Set<UsesNode> uses = new HashSet<>();
 347         when(augmSchema.getUses()).thenReturn(uses);
 348
 349         final List<AugmentationSchemaNode> AugmentationSchemaNodeList = new ArrayList<>();
 350         AugmentationSchemaNodeList.add(augmSchema);
 351         final Map.Entry<SchemaPath, List<AugmentationSchemaNode>> schemaPathAugmentListEntry = mock(Map.Entry.class);
 352         when(schemaPathAugmentListEntry.getKey()).thenReturn(path);
 353         when(schemaPathAugmentListEntry.getValue()).thenReturn(AugmentationSchemaNodeList);
 354
 355         final SchemaContext context = mock(SchemaContext.class);
 356         final Module moduleAug = mock(Module.class);
 357         final DataSchemaNode schNode = mock(DataSchemaNode.class);
 358         when(moduleAug.getDataChildByName(qnamePath)).thenReturn(schNode);
 359         when(context.findModule(qnamePath.getModule())).thenReturn(Optional.of(moduleAug));
 360
 361         final TypeProvider typeProvider = null;
 362         final Map<Module, ModuleContext> genCtx = new HashMap<>();
 363         final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders = new HashMap<>();
 364
 365         final Module m = mock(Module.class);
 366         when(m.getName()).thenReturn("augm-module");
 367         when(m.getNamespace()).thenReturn(qnamePath.getNamespace());
 368         when(m.getRevision()).thenReturn(qnamePath.getRevision());
 369
 370         try {
 371             AugmentToGenType.augmentationToGenTypes(augmPackName, schemaPathAugmentListEntry, m, context, false, genCtx,
 372                 genTypeBuilders, typeProvider);
 373             fail();
 374         } catch (final NullPointerException e) {
 375             assertEquals("Target type not yet generated: " + schNode, e.getMessage());
 376         }
 377     }
 378
 379     @Test
 380     public void augmentationToGenTypesTargetChoicSchemaNodeTest() {
 381         final String augmPackName = "pckg.name";
 382
 383         final AugmentationSchemaNode augmSchema = mock(AugmentationSchemaNode.class);
 384         final QName qnamePath = QName.create("test", "2017-04-04", "aug");
 385         final SchemaPath path = SchemaPath.create(true, qnamePath);
 386         when(augmSchema.getTargetPath()).thenReturn(path);
 387         final Set<UsesNode> uses = new HashSet<>();
 388         when(augmSchema.getUses()).thenReturn(uses);
 389
 390         final List<AugmentationSchemaNode> AugmentationSchemaNodeList = new ArrayList<>();
 391         AugmentationSchemaNodeList.add(augmSchema);
 392         final Map.Entry<SchemaPath, List<AugmentationSchemaNode>> schemaPathAugmentListEntry = mock(Map.Entry.class);
 393         when(schemaPathAugmentListEntry.getKey()).thenReturn(path);
 394         when(schemaPathAugmentListEntry.getValue()).thenReturn(AugmentationSchemaNodeList);
 395
 396         final SchemaContext context = mock(SchemaContext.class);
 397         final Module moduleAug = mock(Module.class);
 398         final ChoiceSchemaNode targetSchNode = mock(ChoiceSchemaNode.class);
 399         when(targetSchNode.getPath()).thenReturn(path);
 400         when(moduleAug.getDataChildByName(qnamePath)).thenReturn(targetSchNode);
 401         when(context.findModule(qnamePath.getModule())).thenReturn(Optional.of(moduleAug));
 402
 403         final TypeProvider typeProvider = null;
 404
 405         final Map<Module, ModuleContext> genCtx = mock(Map.class);
 406         final Collection<ModuleContext> moduleContexts = new ArrayList<>();
 407         final ModuleContext mc = new ModuleContext();
 408         final GeneratedTypeBuilder gtb = new GeneratedTypeBuilderImpl(augmPackName, "augm", mc);
 409         mc.addChildNodeType(targetSchNode, gtb);
 410         moduleContexts.add(mc);
 411         when(genCtx.values()).thenReturn(moduleContexts);
 412
 413         final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders = new HashMap<>();
 414
 415         final Module m = mock(Module.class);
 416         when(m.getName()).thenReturn("augm-module");
 417         when(m.getNamespace()).thenReturn(qnamePath.getNamespace());
 418         when(m.getRevision()).thenReturn(qnamePath.getRevision());
 419
 420         final Map<Module, ModuleContext> result = AugmentToGenType.augmentationToGenTypes(augmPackName,
 421             schemaPathAugmentListEntry, m, context, false, genCtx, genTypeBuilders, typeProvider);
 422         assertNotNull(result);
 423     }
 424
 425     @Test
 426     public void augmentationToGenTypesTest() {
 427         final String augmPackName = "pckg.name";
 428
 429         final AugmentationSchemaNode augmSchema = mock(AugmentationSchemaNode.class);
 430         final QName qnamePath = QName.create("test", "2017-04-04", "aug");
 431         final SchemaPath path = SchemaPath.create(true, qnamePath);
 432         when(augmSchema.getTargetPath()).thenReturn(path);
 433         final Set<UsesNode> uses = new HashSet<>();
 434         when(augmSchema.getUses()).thenReturn(uses);
 435         final List<UnknownSchemaNode> unknownSchemaNodes = new ArrayList<>();
 436         when(augmSchema.getUnknownSchemaNodes()).thenReturn(unknownSchemaNodes);
 437
 438         final List<AugmentationSchemaNode> AugmentationSchemaNodeList = new ArrayList<>();
 439         AugmentationSchemaNodeList.add(augmSchema);
 440         final Map.Entry<SchemaPath, List<AugmentationSchemaNode>> schemaPathAugmentListEntry = mock(Map.Entry.class);
 441         when(schemaPathAugmentListEntry.getKey()).thenReturn(path);
 442         when(schemaPathAugmentListEntry.getValue()).thenReturn(AugmentationSchemaNodeList);
 443
 444         final SchemaContext context = mock(SchemaContext.class);
 445         final Module moduleAug = mock(Module.class);
 446         final DerivableSchemaNode targetSchNode = mock(DerivableSchemaNode.class);
 447         when(targetSchNode.getPath()).thenReturn(path);
 448         when(targetSchNode.isAddedByUses()).thenReturn(true);
 449         when(targetSchNode.getQName()).thenReturn(QName.create("test", "2017-04-04", "aug-node"));
 450         when(moduleAug.getDataChildByName(qnamePath)).thenReturn(targetSchNode);
 451         when(context.findModule(qnamePath.getModule())).thenReturn(Optional.of(moduleAug));
 452
 453         final TypeProvider typeProvider = null;
 454
 455         final Map<Module, ModuleContext> genCtx = new HashMap<>();
 456
 457         final Collection<ModuleContext> moduleContexts = new ArrayList<>();
 458         final ModuleContext mc = new ModuleContext();
 459         final GeneratedTypeBuilder gtb = new GeneratedTypeBuilderImpl(augmPackName, "augm", mc);
 460         mc.addChildNodeType(targetSchNode, gtb);
 461         moduleContexts.add(mc);
 462         genCtx.put(moduleAug, mc);
 463
 464         final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders = new HashMap<>();
 465
 466         when(moduleAug.getName()).thenReturn("augm-module");
 467         when(moduleAug.getNamespace()).thenReturn(qnamePath.getNamespace());
 468         when(moduleAug.getRevision()).thenReturn(qnamePath.getRevision());
 469
 470         final Map<Module, ModuleContext> result =
 471                 AugmentToGenType.augmentationToGenTypes(augmPackName, schemaPathAugmentListEntry, moduleAug, context,
 472                     false, genCtx, genTypeBuilders, typeProvider);
 473         assertNotNull(result);
 474         final ModuleContext moduleContext = result.get(moduleAug);
 475         assertTrue(moduleContext.getAugmentations().get(0).getName().contains("Augm"));
 476         assertEquals("pckg.name.data", moduleContext.getAugmentations().get(0).getPackageName());
 477         assertTrue(moduleContext.getChildNode(path).getName().contains("Augm"));
 478         assertEquals("pckg.name", moduleContext.getChildNode(path).getPackageName());
 479     }
 480
 481     @Test
 482     public void findOriginalTargetFromGroupingNonGroupingTest() {
 483         final Module module = mock(Module.class);
 484         final QName qnamePath = QName.create("test", "2017-04-04", "test");
 485         final SchemaPath schemaPath = SchemaPath.create(true, qnamePath);
 486         final DataSchemaNode schNode = mock(DataSchemaNode.class);
 487         when(schNode.getPath()).thenReturn(schemaPath);
 488         when(module.getDataChildByName(qnamePath)).thenReturn(schNode);
 489
 490         final SchemaContext context = mock(SchemaContext.class);
 491         when(context.findModule(qnamePath.getModule())).thenReturn(Optional.of(module));
 492         final UsesNode usesNode = mock(UsesNode.class);
 493         when(usesNode.getGroupingPath()).thenReturn(schemaPath);
 494
 495         try {
 496             AugmentToGenType.findOriginalTargetFromGrouping(context, schemaPath, usesNode);
 497             fail();
 498         } catch (final IllegalArgumentException e) {
 499             assertEquals("Failed to generate code for augment in " + usesNode, e.getMessage());
 500         }
 501     }
 502
 503     @Test
 504     public void findOriginalTargetFromGroupingAsUsesFailedTest() {
 505         final Module module = mock(Module.class);
 506         final QName qnamePath = QName.create("test", "2017-04-04", "test");
 507         final SchemaPath schemaPath = SchemaPath.create(true, qnamePath);
 508         final DataSchemaNode schNode = mock(DataSchemaNode.class);
 509         when(schNode.getPath()).thenReturn(schemaPath);
 510         when(schNode.isAddedByUses()).thenReturn(true);
 511         final Set<GroupingDefinition> groupings = new HashSet<>();
 512         final GroupingDefinition groupingDefinition = mock(GroupingDefinition.class);
 513         when(groupingDefinition.getQName()).thenReturn(qnamePath);
 514         groupings.add(groupingDefinition);
 515         when(groupingDefinition.getDataChildByName(qnamePath)).thenReturn(schNode);
 516         when(module.getGroupings()).thenReturn(groupings);
 517
 518         final SchemaContext context = mock(SchemaContext.class);
 519         when(context.findModule(qnamePath.getModule())).thenReturn(Optional.of(module));
 520         final UsesNode usesNode = mock(UsesNode.class);
 521         when(usesNode.getGroupingPath()).thenReturn(schemaPath);
 522
 523         final Object[] args = {  };
 524         try {
 525             AugmentToGenType.findOriginalTargetFromGrouping(context, schemaPath, usesNode);
 526             fail();
 527         } catch (final IllegalStateException e) {
 528             assertEquals("Failed to generate code for augment in " + usesNode, e.getMessage());
 529         }
 530     }
 531
 532     @Test
 533     public void findOriginalTargetFromGroupingReturnNullTest() {
 534         final Module module = mock(Module.class);
 535         final QName qnamePath = QName.create("test", "2017-04-04", "test");
 536         final SchemaPath schemaPath = SchemaPath.create(true, qnamePath);
 537         final DataSchemaNode schNode = null;
 538         final Set<GroupingDefinition> groupings = new HashSet<>();
 539         final GroupingDefinition groupingDefinition = mock(GroupingDefinition.class);
 540         when(groupingDefinition.getQName()).thenReturn(qnamePath);
 541         groupings.add(groupingDefinition);
 542         when(groupingDefinition.getDataChildByName(qnamePath)).thenReturn(schNode);
 543         when(module.getGroupings()).thenReturn(groupings);
 544
 545         final SchemaContext context = mock(SchemaContext.class);
 546         when(context.findModule(qnamePath.getModule())).thenReturn(Optional.of(module));
 547         final UsesNode usesNode = mock(UsesNode.class);
 548         when(usesNode.getGroupingPath()).thenReturn(schemaPath);
 549
 550         final Object[] args = {  };
 551         final DataSchemaNode result = AugmentToGenType.findOriginalTargetFromGrouping(context, schemaPath, usesNode);
 552         assertEquals(null, result);
 553     }
 554
 555     @Test
 556     public void findOriginalTargetFromGroupingTest() {
 557         final Module module = mock(Module.class);
 558         final QName qnamePath = QName.create("test", "2017-04-04", "test");
 559         final SchemaPath schemaPath = SchemaPath.create(true, qnamePath);
 560         final DataSchemaNode schNode = mock(DataSchemaNode.class);
 561         when(schNode.getPath()).thenReturn(schemaPath);
 562         final Set<GroupingDefinition> groupings = new HashSet<>();
 563         final GroupingDefinition groupingDefinition = mock(GroupingDefinition.class);
 564         when(groupingDefinition.getQName()).thenReturn(qnamePath);
 565         groupings.add(groupingDefinition);
 566         final DerivableSchemaNode derivSchNode = mock(DerivableSchemaNode.class);
 567         when(derivSchNode.isAddedByUses()).thenReturn(true);
 568         final Optional optional = Optional.of(schNode);
 569         when(derivSchNode.getOriginal()).thenReturn(optional);
 570         when(groupingDefinition.getDataChildByName(qnamePath)).thenReturn(derivSchNode);
 571         when(module.getGroupings()).thenReturn(groupings);
 572
 573         final SchemaContext context = mock(SchemaContext.class);
 574         when(context.findModule(qnamePath.getModule())).thenReturn(Optional.of(module));
 575         final UsesNode usesNode = mock(UsesNode.class);
 576         when(usesNode.getGroupingPath()).thenReturn(schemaPath);
 577
 578         final DataSchemaNode result = AugmentToGenType.findOriginalTargetFromGrouping(context, schemaPath, usesNode);
 579         assertEquals(schNode, result);
 580     }
 581
 582     @Test
 583     public void findOriginalTargetFromGroupingChoiceTest() {
 584         final Module module = mock(Module.class);
 585         final QName qnamePath = QName.create("test", "2017-04-04", "test");
 586         final SchemaPath schemaPath = SchemaPath.create(true, qnamePath);
 587         final ChoiceSchemaNode schNode = mock(ChoiceSchemaNode.class);
 588         when(schNode.getPath()).thenReturn(schemaPath);
 589         final Set<GroupingDefinition> groupings = new HashSet<>();
 590         final GroupingDefinition groupingDefinition = mock(GroupingDefinition.class);
 591         when(groupingDefinition.getQName()).thenReturn(qnamePath);
 592         groupings.add(groupingDefinition);
 593         when(groupingDefinition.getDataChildByName(qnamePath)).thenReturn(schNode);
 594         when(module.getGroupings()).thenReturn(groupings);
 595
 596         final SchemaContext context = mock(SchemaContext.class);
 597         when(context.findModule(qnamePath.getModule())).thenReturn(Optional.of(module));
 598         final UsesNode usesNode = mock(UsesNode.class);
 599         when(usesNode.getGroupingPath()).thenReturn(schemaPath);
 600
 601         final DataSchemaNode result = AugmentToGenType.findOriginalTargetFromGrouping(context, schemaPath, usesNode);
 602         assertEquals(schNode, result);
 603     }
 604
 605     @Test
 606     public void generateTypesFromAugmentedChoiceCasesNullPckgNameTest() {
 607         final SchemaContext schemaContext = null;
 608         final Module module = null;
 609         final String pckgName = null;
 610         final GeneratedType targetType = null;
 611         final ChoiceSchemaNode targetNode = null;
 612         final List<AugmentationSchemaNode> schemaPathAugmentListEntry = null;
 613         final Map<Module, ModuleContext> genCtx = new HashMap<>();
 614         final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilder = new HashMap<>();
 615
 616         try {
 617             AugmentToGenType.generateTypesFromAugmentedChoiceCases(schemaContext, module, pckgName, targetType,
 618                 targetNode, schemaPathAugmentListEntry, genCtx, false, genTypeBuilder, null,
 619                 BindingNamespaceType.Data);
 620             fail();
 621         } catch (final IllegalArgumentException e) {
 622             assertEquals("Base Package Name cannot be NULL.", e.getMessage());
 623         }
 624     }
 625
 626     @Test
 627     public void generateTypesFromAugmentedChoiceCasesNullTargetType() {
 628         final SchemaContext schemaContext = null;
 629         final Module module = null;
 630         final String pckgName = "";
 631         final GeneratedType targetType = null;
 632         final ChoiceSchemaNode targetNode = null;
 633         final List<AugmentationSchemaNode> schemaPathAugmentListEntry = null;
 634         final Map<Module, ModuleContext> genCtx = new HashMap<>();
 635         final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilder = new HashMap<>();
 636
 637         try {
 638             AugmentToGenType.generateTypesFromAugmentedChoiceCases(schemaContext, module, pckgName, targetType,
 639                 targetNode, schemaPathAugmentListEntry, genCtx, false, genTypeBuilder, null,
 640                 BindingNamespaceType.Data);
 641             fail();
 642         } catch (final IllegalArgumentException e) {
 643             assertEquals("Referenced Choice Type cannot be NULL.", e.getMessage());
 644         }
 645     }
 646
 647     @Test
 648     public void generateTypesFromAugmentedChoiceCasesNullAugmentNodes() {
 649         final SchemaContext schemaContext = null;
 650         final Module module = null;
 651         final String pckgName = "";
 652         final GeneratedType targetType = mock(GeneratedType.class);
 653         final ChoiceSchemaNode targetNode = null;
 654         final List<AugmentationSchemaNode> schemaPathAugmentListEntry = null;
 655         final Map<Module, ModuleContext> genCtx = new HashMap<>();
 656         final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilder = new HashMap<>();
 657
 658         try {
 659             AugmentToGenType.generateTypesFromAugmentedChoiceCases(schemaContext, module, pckgName, targetType,
 660                 targetNode, schemaPathAugmentListEntry, genCtx, false, genTypeBuilder, null,
 661                 BindingNamespaceType.Data);
 662             fail();
 663         } catch (final IllegalArgumentException e) {
 664             assertEquals("Set of Choice Case Nodes cannot be NULL.", e.getMessage());
 665         }
 666     }
 667
 668     @Test
 669     public void generateTypesFromAugmentedChoiceCasesNullCaseNodeTest() {
 670         final SchemaContext schemaContext = null;
 671         final Module module = null;
 672         final String pckgName = "";
 673         final GeneratedType targetType = mock(GeneratedType.class);
 674         final ChoiceSchemaNode targetNode = null;
 675         final Set<DataSchemaNode> augmentNodes = new HashSet<>();
 676         final DataSchemaNode caseNode = null;
 677         augmentNodes.add(caseNode);
 678
 679         final AugmentationSchemaNode AugmentationSchemaNode = mock(AugmentationSchemaNode.class);
 680         when(AugmentationSchemaNode.getChildNodes()).thenReturn(augmentNodes);
 681         final List<AugmentationSchemaNode> schemaPathAugmentListEntry = new ArrayList<>();
 682         schemaPathAugmentListEntry.add(AugmentationSchemaNode);
 683
 684         final Map<Module, ModuleContext> genCtx = new HashMap<>();
 685         final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilder = new HashMap<>();
 686
 687         final Map<Module, ModuleContext> result = AugmentToGenType.generateTypesFromAugmentedChoiceCases(schemaContext,
 688             module, pckgName, targetType, targetNode, schemaPathAugmentListEntry, genCtx, false,
 689             genTypeBuilder, null, BindingNamespaceType.Data);
 690         assertEquals(genCtx, result);
 691     }
 692
 693     @Test
 694     public void generateTypesFromAugmentedChoiceCasesTest() {
 695         final QName qnamePath = QName.create("test", "2017-04-04", "chcase");
 696         final QName qnamePath2 = QName.create("test", "2017-04-04", "chcase2");
 697         final SchemaPath path = SchemaPath.create(true, qnamePath, qnamePath2);
 698
 699         final SchemaContext schemaContext = mock(SchemaContext.class);
 700         final Module module = mock(Module.class);
 701         when(module.getName()).thenReturn("test-module-case");
 702         final CaseSchemaNode schemaNode = mock(CaseSchemaNode.class);
 703         when(schemaNode.getPath()).thenReturn(path);
 704         when(module.getDataChildByName(qnamePath)).thenReturn(schemaNode);
 705         when(module.getRevision()).thenReturn(qnamePath.getRevision());
 706         when(module.getNamespace()).thenReturn(qnamePath.getNamespace());
 707         final String pckgName = "test.augment.choice.cases";
 708         final GeneratedType targetType = mock(GeneratedType.class);
 709         when(targetType.getFullyQualifiedName()).thenReturn(Augmentable.class.getName());
 710
 711         final Set<DataSchemaNode> augmentNodes = new HashSet<>();
 712         final CaseSchemaNode caseNode = mock(CaseSchemaNode.class);
 713         when(caseNode.getPath()).thenReturn(path);
 714         when(caseNode.getQName()).thenReturn(qnamePath);
 715         when(caseNode.getDescription()).thenReturn(Optional.empty());
 716         when(caseNode.getReference()).thenReturn(Optional.empty());
 717         augmentNodes.add(caseNode);
 718
 719         final AugmentationSchemaNode AugmentationSchemaNode = mock(AugmentationSchemaNode.class);
 720         when(AugmentationSchemaNode.getChildNodes()).thenReturn(augmentNodes);
 721         final List<AugmentationSchemaNode> schemaPathAugmentListEntry = new ArrayList<>();
 722         schemaPathAugmentListEntry.add(AugmentationSchemaNode);
 723
 724         final ChoiceSchemaNode targetNode = mock(ChoiceSchemaNode.class);
 725         when(targetNode.getPath()).thenReturn(path);
 726         when(targetNode.getDescription()).thenReturn(Optional.empty());
 727         when(targetNode.getReference()).thenReturn(Optional.empty());
 728         final Map<Module, ModuleContext> genCtx = new HashMap<>();
 729         final ModuleContext moduleContext = new ModuleContext();
 730         final GeneratedTypeBuilder gtb = new GeneratedTypeBuilderImpl(pckgName, "test-case-node-augment", moduleContext);
 731         when(targetType.getParentTypeForBuilder()).thenReturn(gtb);
 732         genCtx.put(module, moduleContext);
 733         final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilder = new HashMap<>();
 734
 735         when(schemaContext.findModule(qnamePath.getModule())).thenReturn(Optional.of(module));
 736
 737         final Map<Module, ModuleContext> result = AugmentToGenType.generateTypesFromAugmentedChoiceCases(schemaContext,
 738             module, pckgName, targetType, targetNode, schemaPathAugmentListEntry, genCtx, false,
 739             genTypeBuilder, null, BindingNamespaceType.Data);
 740         assertNotNull(result);
 741         assertEquals(result.get(module), moduleContext);
 742     }
 743 }