opendaylight/sal/yang-prototype/code-generator/yang-model-parser-impl/src/test/java/org/opendaylight/controller/yang/model/parser/impl/YangModelParserTest.java

   1 /*
   2  * Copyright (c) 2013 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.controller.yang.model.parser.impl;
   9
  10 import static org.junit.Assert.*;
  11
  12 import java.util.HashSet;
  13 import java.util.List;
  14 import java.util.Set;
  15
  16 import org.junit.Before;
  17 import org.junit.Test;
  18 import org.opendaylight.controller.yang.common.QName;
  19 import org.opendaylight.controller.yang.model.api.AugmentationSchema;
  20 import org.opendaylight.controller.yang.model.api.ContainerSchemaNode;
  21 import org.opendaylight.controller.yang.model.api.LeafSchemaNode;
  22 import org.opendaylight.controller.yang.model.api.ListSchemaNode;
  23 import org.opendaylight.controller.yang.model.api.Module;
  24 import org.opendaylight.controller.yang.model.api.TypeDefinition;
  25 import org.opendaylight.controller.yang.model.api.type.LengthConstraint;
  26 import org.opendaylight.controller.yang.model.api.type.PatternConstraint;
  27 import org.opendaylight.controller.yang.model.api.type.RangeConstraint;
  28 import org.opendaylight.controller.yang.model.parser.api.YangModelParser;
  29 import org.opendaylight.controller.yang.model.util.Decimal64;
  30 import org.opendaylight.controller.yang.model.util.ExtendedType;
  31 import org.opendaylight.controller.yang.model.util.Int16;
  32 import org.opendaylight.controller.yang.model.util.Int32;
  33 import org.opendaylight.controller.yang.model.util.StringType;
  34 import org.opendaylight.controller.yang.model.util.UnionType;
  35
  36 public class YangModelParserTest {
  37
  38     private static final String TEST_FILE1 = "src/test/resources/model/testfile1.yang";
  39     private static final String TEST_FILE2 = "src/test/resources/model/testfile2.yang";
  40     private YangModelParser tested;
  41
  42     @Before
  43     public void init() {
  44         tested = new YangModelParserImpl();
  45     }
  46
  47     @Test
  48     public void testAugment() {
  49         Set<Module> modules = tested.parseYangModels(TEST_FILE1, TEST_FILE2);
  50         assertEquals(2, modules.size());
  51
  52         Module testModule = findModule(modules, "types2");
  53         assertNotNull(testModule);
  54
  55         AugmentationSchema augment = testModule.getAugmentations().iterator().next();
  56         assertNotNull(augment);
  57     }
  58
  59     @Test
  60     public void testAugmentTarget() {
  61         Set<Module> modules = tested.parseYangModels(TEST_FILE1, TEST_FILE2);
  62         assertEquals(2, modules.size());
  63
  64         Module testModule = findModule(modules, "types1");
  65         assertNotNull(testModule);
  66
  67         ContainerSchemaNode container = (ContainerSchemaNode)testModule.getDataChildByName("interfaces");
  68         assertNotNull(container);
  69
  70         ListSchemaNode list = (ListSchemaNode)container.getDataChildByName("ifEntry");
  71         assertNotNull(list);
  72         assertEquals(1, list.getAvailableAugmentations().size());
  73
  74         LeafSchemaNode leaf = (LeafSchemaNode)list.getDataChildByName("ds0ChannelNumber");
  75         assertNotNull(leaf);
  76     }
  77
  78     @Test
  79     public void testTypedefRangesResolving() {
  80         Set<Module> modules = tested.parseYangModels(TEST_FILE1, TEST_FILE2);
  81         assertEquals(2, modules.size());
  82
  83         Module testModule = findModule(modules, "types1");
  84         assertNotNull(testModule);
  85
  86         LeafSchemaNode testleaf = (LeafSchemaNode)testModule.getDataChildByName("testleaf");
  87         ExtendedType leafType = (ExtendedType)testleaf.getType();
  88         assertEquals("my-type1", leafType.getQName().getLocalName());
  89         assertEquals("t2", leafType.getQName().getPrefix());
  90         ExtendedType baseType = (ExtendedType)leafType.getBaseType();
  91         assertEquals("my-base-int32-type", baseType.getQName().getLocalName());
  92         assertEquals("t2", baseType.getQName().getPrefix());
  93
  94         List<RangeConstraint> ranges = leafType.getRanges();
  95         assertEquals(1, ranges.size());
  96         RangeConstraint range = ranges.get(0);
  97         assertEquals(11L, range.getMin());
  98         assertEquals(20L, range.getMax());
  99     }
 100
 101     @Test
 102     public void testTypedefPatternsResolving() {
 103         Set<Module> modules = tested.parseYangModels(TEST_FILE1, TEST_FILE2);
 104         assertEquals(2, modules.size());
 105
 106         Module testModule = findModule(modules, "types1");
 107         assertNotNull(testModule);
 108
 109         LeafSchemaNode testleaf = (LeafSchemaNode)testModule.getDataChildByName("test-string-leaf");
 110         ExtendedType testleafType = (ExtendedType)testleaf.getType();
 111         QName testleafTypeQName = testleafType.getQName();
 112         assertEquals("my-string-type-ext", testleafTypeQName.getLocalName());
 113         assertEquals("t2", testleafTypeQName.getPrefix());
 114
 115         Set<String> expectedRegex = new HashSet<String>();
 116         expectedRegex.add("[a-k]*");
 117         expectedRegex.add("[b-u]*");
 118         expectedRegex.add("[e-z]*");
 119
 120         Set<String> actualRegex = new HashSet<String>();
 121         List<PatternConstraint> patterns = testleafType.getPatterns();
 122         assertEquals(3, patterns.size());
 123         for (PatternConstraint pc : patterns) {
 124             actualRegex.add(pc.getRegularExpression());
 125         }
 126         assertEquals(expectedRegex, actualRegex);
 127
 128         TypeDefinition<?> baseType = testleafType.getBaseType();
 129         assertEquals("my-string-type2", baseType.getQName().getLocalName());
 130
 131         List<LengthConstraint> lengths = testleafType.getLengths();
 132         assertEquals(1, lengths.size());
 133
 134         LengthConstraint length = lengths.get(0);
 135         assertEquals(5L, length.getMin());
 136         assertEquals(10L, length.getMax());
 137     }
 138
 139     @Test
 140     public void testTypedefLengthsResolving() {
 141         Set<Module> modules = tested.parseYangModels(TEST_FILE1, TEST_FILE2);
 142         assertEquals(2, modules.size());
 143
 144         Module testModule = findModule(modules, "types1");
 145         assertNotNull(testModule);
 146
 147         LeafSchemaNode testleaf = (LeafSchemaNode)testModule.getDataChildByName("leaf-with-length");
 148         ExtendedType testleafType = (ExtendedType)testleaf.getType();
 149         assertEquals("my-string-type", testleafType.getQName().getLocalName());
 150
 151         List<LengthConstraint> lengths = testleafType.getLengths();
 152         assertEquals(1, lengths.size());
 153
 154         LengthConstraint length = lengths.get(0);
 155         assertEquals(7L, length.getMin());
 156         assertEquals(10L, length.getMax());
 157     }
 158
 159     @Test
 160     public void testTypeDef() {
 161         Set<Module> modules = tested.parseYangModels(TEST_FILE1, TEST_FILE2);
 162         assertEquals(2, modules.size());
 163
 164         Module testModule = findModule(modules, "types2");
 165         assertNotNull(testModule);
 166
 167         LeafSchemaNode testleaf = (LeafSchemaNode)testModule.getDataChildByName("nested-type-leaf");
 168         ExtendedType testleafType = (ExtendedType)testleaf.getType();
 169         assertEquals("my-type1", testleafType.getQName().getLocalName());
 170
 171         ExtendedType baseType = (ExtendedType)testleafType.getBaseType();
 172         assertEquals("my-base-int32-type", baseType.getQName().getLocalName());
 173
 174         Int32 int32base = (Int32)baseType.getBaseType();
 175         List<RangeConstraint> ranges = int32base.getRangeStatements();
 176         assertEquals(1, ranges.size());
 177         RangeConstraint range = ranges.get(0);
 178         assertEquals(2L, range.getMin());
 179         assertEquals(20L, range.getMax());
 180     }
 181
 182     @Test
 183     public void testTypedefDecimal1() {
 184         Set<Module> modules = tested.parseYangModels(TEST_FILE1, TEST_FILE2);
 185         assertEquals(2, modules.size());
 186
 187         Module testModule = findModule(modules, "types1");
 188         assertNotNull(testModule);
 189
 190         LeafSchemaNode testleaf = (LeafSchemaNode)testModule.getDataChildByName("test-decimal-leaf");
 191         ExtendedType type = (ExtendedType)testleaf.getType();
 192
 193         TypeDefinition<?> baseType = type.getBaseType();
 194         assertTrue(baseType instanceof Decimal64);
 195         Decimal64 baseTypeCast = (Decimal64)baseType;
 196         assertEquals(6, (int)baseTypeCast.getFractionDigits());
 197     }
 198
 199     @Test
 200     public void testTypedefDecimal2() {
 201         Set<Module> modules = tested.parseYangModels(TEST_FILE1, TEST_FILE2);
 202         assertEquals(2, modules.size());
 203
 204         Module testModule = findModule(modules, "types1");
 205         assertNotNull(testModule);
 206
 207         LeafSchemaNode testleaf = (LeafSchemaNode)testModule.getDataChildByName("test-decimal-leaf2");
 208         TypeDefinition<?> baseType = testleaf.getType().getBaseType();
 209         assertTrue(testleaf.getType().getBaseType() instanceof Decimal64);
 210         Decimal64 baseTypeCast = (Decimal64)baseType;
 211         assertEquals(5, (int)baseTypeCast.getFractionDigits());
 212     }
 213
 214     @Test
 215     public void testTypedefUnion() {
 216         Set<Module> modules = tested.parseYangModels(TEST_FILE1, TEST_FILE2);
 217         assertEquals(2, modules.size());
 218
 219         Module testModule = findModule(modules, "types1");
 220         assertNotNull(testModule);
 221
 222         LeafSchemaNode testleaf = (LeafSchemaNode)testModule.getDataChildByName("union-leaf");
 223         ExtendedType testleafType = (ExtendedType)testleaf.getType();
 224         assertEquals("my-union-ext", testleafType.getQName().getLocalName());
 225
 226         ExtendedType baseType = (ExtendedType)testleafType.getBaseType();
 227         assertEquals("my-union", baseType.getQName().getLocalName());
 228
 229         UnionType unionBase = (UnionType) baseType.getBaseType();
 230
 231         List<TypeDefinition<?>> unionTypes = unionBase.getTypes();
 232         Int16 unionType1 = (Int16)unionTypes.get(0);
 233         List<RangeConstraint> ranges = unionType1.getRangeStatements();
 234         assertEquals(1, ranges.size());
 235         RangeConstraint range = ranges.get(0);
 236         assertEquals(1L, range.getMin());
 237         assertEquals(100L, range.getMax());
 238
 239         assertTrue(unionTypes.get(0) instanceof Int16);
 240         assertTrue(unionTypes.get(1) instanceof Int32);
 241     }
 242
 243     @Test
 244     public void testNestedUnionResolving() {
 245         Set<Module> modules = tested.parseYangModels(TEST_FILE1, TEST_FILE2);
 246         assertEquals(2, modules.size());
 247
 248         Module testModule = findModule(modules, "types1");
 249         assertNotNull(testModule);
 250
 251         LeafSchemaNode testleaf = (LeafSchemaNode)testModule.getDataChildByName("nested-union-leaf");
 252
 253         ExtendedType nestedUnion1 = (ExtendedType)testleaf.getType();
 254         assertEquals("nested-union1", nestedUnion1.getQName().getLocalName());
 255
 256         ExtendedType nestedUnion2 = (ExtendedType)nestedUnion1.getBaseType();
 257         assertEquals("nested-union2", nestedUnion2.getQName().getLocalName());
 258
 259         UnionType unionType1 = (UnionType)nestedUnion2.getBaseType();
 260         List<TypeDefinition<?>> unionTypes = unionType1.getTypes();
 261         assertEquals(2, unionTypes.size());
 262         assertTrue(unionTypes.get(0) instanceof StringType);
 263         assertTrue(unionTypes.get(1) instanceof ExtendedType);
 264
 265         ExtendedType extendedUnion = (ExtendedType)unionTypes.get(1);
 266         ExtendedType extendedUnionBase = (ExtendedType)extendedUnion.getBaseType();
 267         assertEquals("my-union", extendedUnionBase.getQName().getLocalName());
 268
 269         UnionType extendedTargetUnion = (UnionType)extendedUnionBase.getBaseType();
 270         List<TypeDefinition<?>> extendedTargetTypes = extendedTargetUnion.getTypes();
 271         assertTrue(extendedTargetTypes.get(0) instanceof Int16);
 272         assertTrue(extendedTargetTypes.get(1) instanceof Int32);
 273
 274         Int16 int16 = (Int16) extendedTargetTypes.get(0);
 275         List<RangeConstraint> ranges = int16.getRangeStatements();
 276         assertEquals(1, ranges.size());
 277         RangeConstraint range = ranges.get(0);
 278         assertEquals(1L, range.getMin());
 279         assertEquals(100L, range.getMax());
 280     }
 281
 282     private Module findModule(Set<Module> modules, String moduleName) {
 283         Module result = null;
 284         for(Module module : modules) {
 285             if(module.getName().equals(moduleName)) {
 286                 result = module;
 287                 break;
 288             }
 289         }
 290         return result;
 291     }
 292
 293 }