*/
package org.opendaylight.yangtools.yang.parser.impl;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.math.BigInteger;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Date;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
-import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
+import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Deviation.Deviate;
import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
import org.opendaylight.yangtools.yang.model.api.FeatureDefinition;
-import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
-import org.opendaylight.yangtools.yang.model.parser.api.YangModelParser;
+import org.opendaylight.yangtools.yang.model.parser.api.YangContextParser;
+import org.opendaylight.yangtools.yang.model.parser.api.YangSyntaxErrorException;
import org.opendaylight.yangtools.yang.model.util.Decimal64;
import org.opendaylight.yangtools.yang.model.util.ExtendedType;
import org.opendaylight.yangtools.yang.model.util.Int16;
import org.opendaylight.yangtools.yang.model.util.StringType;
import org.opendaylight.yangtools.yang.model.util.Uint32;
import org.opendaylight.yangtools.yang.model.util.UnionType;
-
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileNotFoundException;
-import java.io.InputStream;
-import java.net.URI;
-import java.net.URISyntaxException;
-import java.text.DateFormat;
-import java.text.ParseException;
-import java.text.SimpleDateFormat;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Date;
-import java.util.Iterator;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
+import org.opendaylight.yangtools.yang.parser.builder.impl.BuilderUtils;
+import org.opendaylight.yangtools.yang.parser.util.YangParseException;
public class YangParserTest {
public static final String FS = File.separator;
assertEquals(" WILL BE DEFINED LATER", foo.getReference());
}
- @Test
- public void testOrderingTypedef() {
- Module bar = TestUtils.findModule(modules, "bar");
- Set<TypeDefinition<?>> typedefs = bar.getTypeDefinitions();
- String[] expectedOrder = new String[] { "int32-ext1", "int32-ext2", "my-decimal-type", "my-union",
- "my-union-ext", "nested-union2", "string-ext1", "string-ext2", "string-ext3", "string-ext4" };
- String[] actualOrder = new String[typedefs.size()];
-
- int i = 0;
- for (TypeDefinition<?> type : typedefs) {
- actualOrder[i] = type.getQName().getLocalName();
- i++;
- }
- assertArrayEquals(expectedOrder, actualOrder);
- }
-
- @Test
- public void testOrderingChildNodes() {
- Module foo = TestUtils.findModule(modules, "foo");
- AugmentationSchema augment1 = null;
- for (AugmentationSchema as : foo.getAugmentations()) {
- if ("if:ifType='ds0'".equals(as.getWhenCondition().toString())) {
- augment1 = as;
- break;
- }
- }
- assertNotNull(augment1);
-
- String[] expectedOrder = new String[] { "ds0ChannelNumber", "interface-id", "my-type", "odl", "schemas" };
- String[] actualOrder = new String[expectedOrder.length];
-
- int i = 0;
- for (DataSchemaNode augmentChild : augment1.getChildNodes()) {
- actualOrder[i] = augmentChild.getQName().getLocalName();
- i++;
- }
-
- assertArrayEquals(expectedOrder, actualOrder);
- }
-
- @Test
- public void testOrderingNestedChildNodes1() {
- Module foo = TestUtils.findModule(modules, "foo");
-
- Set<DataSchemaNode> childNodes = foo.getChildNodes();
- String[] expectedOrder = new String[] { "address", "addresses", "custom-union-leaf", "data", "datas",
- "decimal-leaf", "decimal-leaf2", "ext", "how", "int32-leaf", "length-leaf", "mycont", "peer", "port",
- "string-leaf", "transfer", "union-leaf" };
- String[] actualOrder = new String[childNodes.size()];
-
- int i = 0;
- for (DataSchemaNode child : childNodes) {
- actualOrder[i] = child.getQName().getLocalName();
- i++;
- }
- assertArrayEquals(expectedOrder, actualOrder);
- }
-
- @Test
- public void testOrderingNestedChildNodes2() {
- Module baz = TestUtils.findModule(modules, "baz");
- Set<GroupingDefinition> groupings = baz.getGroupings();
- assertEquals(1, groupings.size());
- GroupingDefinition target = groupings.iterator().next();
-
- Set<DataSchemaNode> childNodes = target.getChildNodes();
- String[] expectedOrder = new String[] { "address", "addresses", "data", "how", "port" };
- String[] actualOrder = new String[childNodes.size()];
-
- int i = 0;
- for (DataSchemaNode child : childNodes) {
- actualOrder[i] = child.getQName().getLocalName();
- i++;
- }
- assertArrayEquals(expectedOrder, actualOrder);
- }
-
@Test
public void testParseList() {
Module bar = TestUtils.findModule(modules, "bar");
ListSchemaNode ifEntry = (ListSchemaNode) interfaces.getDataChildByName("ifEntry");
// test SchemaNode args
- QName expectedQName = new QName(expectedNamespace, barRev, expectedPrefix, "ifEntry");
+ QName expectedQName = QName.create(expectedNamespace, barRev, "ifEntry");
assertEquals(expectedQName, ifEntry.getQName());
SchemaPath expectedPath = TestUtils.createPath(true, expectedNamespace, barRev, expectedPrefix, "interfaces",
"ifEntry");
ConstraintDefinition constraints = ifEntry.getConstraints();
assertNull(constraints.getWhenCondition());
assertEquals(0, constraints.getMustConstraints().size());
- assertFalse(constraints.isMandatory());
+ assertTrue(constraints.isMandatory());
assertEquals(1, (int) constraints.getMinElements());
assertEquals(11, (int) constraints.getMaxElements());
// test AugmentationTarget args
assertEquals(2, availableAugmentations.size());
// test ListSchemaNode args
List<QName> expectedKey = new ArrayList<>();
- expectedKey.add(new QName(expectedNamespace, barRev, expectedPrefix, "ifIndex"));
+ expectedKey.add(QName.create(expectedNamespace, barRev, "ifIndex"));
assertEquals(expectedKey, ifEntry.getKeyDefinition());
assertFalse(ifEntry.isUserOrdered());
// test DataNodeContainer args
ExtendedType leafType = (ExtendedType) int32Leaf.getType();
QName leafTypeQName = leafType.getQName();
assertEquals("int32-ext2", leafTypeQName.getLocalName());
- assertEquals("foo", leafTypeQName.getPrefix());
assertEquals(fooNS, leafTypeQName.getNamespace());
assertEquals(fooRev, leafTypeQName.getRevision());
assertNull(leafType.getUnits());
List<RangeConstraint> ranges = leafType.getRangeConstraints();
assertEquals(1, ranges.size());
RangeConstraint range = ranges.get(0);
- assertEquals(12L, range.getMin());
- assertEquals(20L, range.getMax());
+ assertEquals(BigInteger.valueOf(12), range.getMin());
+ assertEquals(BigInteger.valueOf(20), range.getMax());
ExtendedType baseType = (ExtendedType) leafType.getBaseType();
QName baseTypeQName = baseType.getQName();
assertEquals("int32-ext2", baseTypeQName.getLocalName());
- assertEquals("bar", baseTypeQName.getPrefix());
assertEquals(barNS, baseTypeQName.getNamespace());
assertEquals(barRev, baseTypeQName.getRevision());
assertEquals("mile", baseType.getUnits());
List<RangeConstraint> baseTypeRanges = baseType.getRangeConstraints();
assertEquals(2, baseTypeRanges.size());
RangeConstraint baseTypeRange1 = baseTypeRanges.get(0);
- assertEquals(3L, baseTypeRange1.getMin());
- assertEquals(9L, baseTypeRange1.getMax());
+ assertEquals(BigInteger.valueOf(3), baseTypeRange1.getMin());
+ assertEquals(BigInteger.valueOf(9), baseTypeRange1.getMax());
RangeConstraint baseTypeRange2 = baseTypeRanges.get(1);
- assertEquals(11L, baseTypeRange2.getMin());
- assertEquals(20L, baseTypeRange2.getMax());
+ assertEquals(BigInteger.valueOf(11), baseTypeRange2.getMin());
+ assertEquals(BigInteger.valueOf(20), baseTypeRange2.getMax());
ExtendedType base = (ExtendedType) baseType.getBaseType();
QName baseQName = base.getQName();
assertEquals("int32-ext1", baseQName.getLocalName());
- assertEquals("bar", baseQName.getPrefix());
assertEquals(barNS, baseQName.getNamespace());
assertEquals(barRev, baseQName.getRevision());
assertNull(base.getUnits());
List<RangeConstraint> baseRanges = base.getRangeConstraints();
assertEquals(1, baseRanges.size());
RangeConstraint baseRange = baseRanges.get(0);
- assertEquals(2L, baseRange.getMin());
- assertEquals(20L, baseRange.getMax());
+ assertEquals(BigInteger.valueOf(2), baseRange.getMin());
+ assertEquals(BigInteger.valueOf(20), baseRange.getMax());
assertTrue(base.getBaseType() instanceof Int32);
}
ExtendedType type = (ExtendedType) stringleaf.getType();
QName typeQName = type.getQName();
assertEquals("string-ext4", typeQName.getLocalName());
- assertEquals("bar", typeQName.getPrefix());
assertEquals(barNS, typeQName.getNamespace());
assertEquals(barRev, typeQName.getRevision());
assertNull(type.getUnits());
List<PatternConstraint> patterns = type.getPatternConstraints();
assertEquals(1, patterns.size());
PatternConstraint pattern = patterns.iterator().next();
- assertEquals("[e-z]*", pattern.getRegularExpression());
+ assertEquals("^[e-z]*$", pattern.getRegularExpression());
assertTrue(type.getLengthConstraints().isEmpty());
assertTrue(type.getRangeConstraints().isEmpty());
ExtendedType baseType1 = (ExtendedType) type.getBaseType();
QName baseType1QName = baseType1.getQName();
assertEquals("string-ext3", baseType1QName.getLocalName());
- assertEquals("bar", baseType1QName.getPrefix());
assertEquals(barNS, baseType1QName.getNamespace());
assertEquals(barRev, baseType1QName.getRevision());
assertNull(baseType1.getUnits());
patterns = baseType1.getPatternConstraints();
assertEquals(1, patterns.size());
pattern = patterns.iterator().next();
- assertEquals("[b-u]*", pattern.getRegularExpression());
+ assertEquals("^[b-u]*$", pattern.getRegularExpression());
assertTrue(baseType1.getLengthConstraints().isEmpty());
assertTrue(baseType1.getRangeConstraints().isEmpty());
ExtendedType baseType2 = (ExtendedType) baseType1.getBaseType();
QName baseType2QName = baseType2.getQName();
assertEquals("string-ext2", baseType2QName.getLocalName());
- assertEquals("bar", baseType2QName.getPrefix());
assertEquals(barNS, baseType2QName.getNamespace());
assertEquals(barRev, baseType2QName.getRevision());
assertNull(baseType2.getUnits());
List<LengthConstraint> baseType2Lengths = baseType2.getLengthConstraints();
assertEquals(1, baseType2Lengths.size());
LengthConstraint length = baseType2Lengths.get(0);
- assertEquals(6L, length.getMin());
- assertEquals(10L, length.getMax());
+ assertEquals(BigInteger.valueOf(6), length.getMin());
+ assertEquals(BigInteger.TEN, length.getMax());
assertTrue(baseType2.getRangeConstraints().isEmpty());
ExtendedType baseType3 = (ExtendedType) baseType2.getBaseType();
QName baseType3QName = baseType3.getQName();
assertEquals("string-ext1", baseType3QName.getLocalName());
- assertEquals("bar", baseType3QName.getPrefix());
assertEquals(barNS, baseType3QName.getNamespace());
assertEquals(barRev, baseType3QName.getRevision());
assertNull(baseType3.getUnits());
patterns = baseType3.getPatternConstraints();
assertEquals(1, patterns.size());
pattern = patterns.iterator().next();
- assertEquals("[a-k]*", pattern.getRegularExpression());
+ assertEquals("^[a-k]*$", pattern.getRegularExpression());
List<LengthConstraint> baseType3Lengths = baseType3.getLengthConstraints();
assertEquals(1, baseType3Lengths.size());
length = baseType3Lengths.get(0);
- assertEquals(5L, length.getMin());
- assertEquals(11L, length.getMax());
+ assertEquals(BigInteger.valueOf(5), length.getMin());
+ assertEquals(BigInteger.valueOf(11), length.getMax());
assertTrue(baseType3.getRangeConstraints().isEmpty());
assertTrue(baseType3.getBaseType() instanceof StringType);
}
+ @Test
+ public void testTypedefInvalidPatternsResolving() {
+ Module foo = TestUtils.findModule(modules, "foo");
+ final LeafSchemaNode invalidPatternStringLeaf = (LeafSchemaNode) foo.getDataChildByName("invalid-pattern-string-leaf");
+ ExtendedType type = (ExtendedType) invalidPatternStringLeaf.getType();
+ QName typeQName = type.getQName();
+ assertEquals("invalid-string-pattern", typeQName.getLocalName());
+ assertEquals(barNS, typeQName.getNamespace());
+ assertEquals(barRev, typeQName.getRevision());
+ assertNull(type.getUnits());
+ assertNull(type.getDefaultValue());
+ List<PatternConstraint> patterns = type.getPatternConstraints();
+ assertTrue(patterns.isEmpty());
+
+ final LeafSchemaNode invalidDirectStringPatternDefLeaf = (LeafSchemaNode) foo.getDataChildByName("invalid-direct-string-pattern-def-leaf");
+ type = (ExtendedType) invalidDirectStringPatternDefLeaf.getType();
+ typeQName = type.getQName();
+ assertEquals("string", typeQName.getLocalName());
+ assertEquals(fooNS, typeQName.getNamespace());
+ assertEquals(fooRev, typeQName.getRevision());
+ assertNull(type.getUnits());
+ assertNull(type.getDefaultValue());
+ patterns = type.getPatternConstraints();
+ assertTrue(patterns.isEmpty());
+
+ final LeafSchemaNode multiplePatternStringLeaf = (LeafSchemaNode) foo.getDataChildByName("multiple-pattern-string-leaf");
+ type = (ExtendedType) multiplePatternStringLeaf.getType();
+ typeQName = type.getQName();
+ assertEquals("multiple-pattern-string", typeQName.getLocalName());
+ assertEquals(barNS, typeQName.getNamespace());
+ assertEquals(barRev, typeQName.getRevision());
+ assertNull(type.getUnits());
+ assertNull(type.getDefaultValue());
+ patterns = type.getPatternConstraints();
+ assertTrue(!patterns.isEmpty());
+ assertEquals(1, patterns.size());
+ PatternConstraint pattern = patterns.iterator().next();
+ assertEquals("^[e-z]*$", pattern.getRegularExpression());
+ assertTrue(type.getLengthConstraints().isEmpty());
+ assertTrue(type.getRangeConstraints().isEmpty());
+
+ final LeafSchemaNode multiplePatternDirectStringDefLeaf = (LeafSchemaNode) foo.getDataChildByName("multiple-pattern-direct-string-def-leaf");
+ type = (ExtendedType) multiplePatternDirectStringDefLeaf.getType();
+ typeQName = type.getQName();
+ assertEquals("string", typeQName.getLocalName());
+ assertEquals(fooNS, typeQName.getNamespace());
+ assertEquals(fooRev, typeQName.getRevision());
+ assertNull(type.getUnits());
+ assertNull(type.getDefaultValue());
+ patterns = type.getPatternConstraints();
+ assertTrue(!patterns.isEmpty());
+ assertEquals(2, patterns.size());
+
+ boolean isEZPattern = false;
+ boolean isADPattern = false;
+ for (final PatternConstraint patternConstraint : patterns) {
+ if (patternConstraint.getRegularExpression().equals("^[e-z]*$")) {
+ isEZPattern = true;
+ } else if (patternConstraint.getRegularExpression().equals("^[a-d]*$")) {
+ isADPattern = true;
+ }
+ }
+ assertTrue(isEZPattern);
+ assertTrue( isADPattern);
+ }
+
@Test
public void testTypedefLengthsResolving() {
Module foo = TestUtils.findModule(modules, "foo");
QName typeQName = type.getQName();
assertEquals("string-ext2", typeQName.getLocalName());
- assertEquals("foo", typeQName.getPrefix());
assertEquals(fooNS, typeQName.getNamespace());
assertEquals(fooRev, typeQName.getRevision());
assertNull(type.getUnits());
List<LengthConstraint> typeLengths = type.getLengthConstraints();
assertEquals(1, typeLengths.size());
LengthConstraint length = typeLengths.get(0);
- assertEquals(7L, length.getMin());
- assertEquals(10L, length.getMax());
+ assertEquals(BigInteger.valueOf(7), length.getMin());
+ assertEquals(BigInteger.TEN, length.getMax());
assertTrue(type.getRangeConstraints().isEmpty());
ExtendedType baseType1 = (ExtendedType) type.getBaseType();
QName baseType1QName = baseType1.getQName();
assertEquals("string-ext2", baseType1QName.getLocalName());
- assertEquals("bar", baseType1QName.getPrefix());
assertEquals(barNS, baseType1QName.getNamespace());
assertEquals(barRev, baseType1QName.getRevision());
assertNull(baseType1.getUnits());
List<LengthConstraint> baseType2Lengths = baseType1.getLengthConstraints();
assertEquals(1, baseType2Lengths.size());
length = baseType2Lengths.get(0);
- assertEquals(6L, length.getMin());
- assertEquals(10L, length.getMax());
+ assertEquals(BigInteger.valueOf(6), length.getMin());
+ assertEquals(BigInteger.TEN, length.getMax());
assertTrue(baseType1.getRangeConstraints().isEmpty());
ExtendedType baseType2 = (ExtendedType) baseType1.getBaseType();
QName baseType2QName = baseType2.getQName();
assertEquals("string-ext1", baseType2QName.getLocalName());
- assertEquals("bar", baseType2QName.getPrefix());
assertEquals(barNS, baseType2QName.getNamespace());
assertEquals(barRev, baseType2QName.getRevision());
assertNull(baseType2.getUnits());
List<PatternConstraint> patterns = baseType2.getPatternConstraints();
assertEquals(1, patterns.size());
PatternConstraint pattern = patterns.iterator().next();
- assertEquals("[a-k]*", pattern.getRegularExpression());
+ assertEquals("^[a-k]*$", pattern.getRegularExpression());
List<LengthConstraint> baseType3Lengths = baseType2.getLengthConstraints();
assertEquals(1, baseType3Lengths.size());
length = baseType3Lengths.get(0);
- assertEquals(5L, length.getMin());
- assertEquals(11L, length.getMax());
+ assertEquals(BigInteger.valueOf(5), length.getMin());
+ assertEquals(BigInteger.valueOf(11), length.getMax());
assertTrue(baseType2.getRangeConstraints().isEmpty());
assertTrue(baseType2.getBaseType() instanceof StringType);
ExtendedType type = (ExtendedType) testleaf.getType();
QName typeQName = type.getQName();
assertEquals("my-decimal-type", typeQName.getLocalName());
- assertEquals("foo", typeQName.getPrefix());
assertEquals(fooNS, typeQName.getNamespace());
assertEquals(fooRev, typeQName.getRevision());
assertNull(type.getUnits());
ExtendedType typeBase = (ExtendedType) type.getBaseType();
QName typeBaseQName = typeBase.getQName();
assertEquals("my-decimal-type", typeBaseQName.getLocalName());
- assertEquals("bar", typeBaseQName.getPrefix());
assertEquals(barNS, typeBaseQName.getNamespace());
assertEquals(barRev, typeBaseQName.getRevision());
assertNull(typeBase.getUnits());
ExtendedType type = (ExtendedType) testleaf.getType();
QName typeQName = type.getQName();
assertEquals("my-decimal-type", typeQName.getLocalName());
- assertEquals("bar", typeQName.getPrefix());
assertEquals(barNS, typeQName.getNamespace());
assertEquals(barRev, typeQName.getRevision());
assertNull(type.getUnits());
ExtendedType type = (ExtendedType) unionleaf.getType();
QName typeQName = type.getQName();
assertEquals("my-union-ext", typeQName.getLocalName());
- assertEquals("bar", typeQName.getPrefix());
assertEquals(barNS, typeQName.getNamespace());
assertEquals(barRev, typeQName.getRevision());
assertNull(type.getUnits());
ExtendedType baseType = (ExtendedType) type.getBaseType();
QName baseTypeQName = baseType.getQName();
assertEquals("my-union", baseTypeQName.getLocalName());
- assertEquals("bar", baseTypeQName.getPrefix());
assertEquals(barNS, baseTypeQName.getNamespace());
assertEquals(barRev, baseTypeQName.getRevision());
assertNull(baseType.getUnits());
ExtendedType unionType1 = (ExtendedType) unionTypes.get(0);
QName unionType1QName = baseType.getQName();
assertEquals("my-union", unionType1QName.getLocalName());
- assertEquals("bar", unionType1QName.getPrefix());
assertEquals(barNS, unionType1QName.getNamespace());
assertEquals(barRev, unionType1QName.getRevision());
assertNull(unionType1.getUnits());
List<RangeConstraint> ranges = unionType1.getRangeConstraints();
assertEquals(1, ranges.size());
RangeConstraint range = ranges.get(0);
- assertEquals(1L, range.getMin());
- assertEquals(100L, range.getMax());
+ assertEquals(BigInteger.ONE, range.getMin());
+ assertEquals(BigInteger.valueOf(100), range.getMax());
assertTrue(unionType1.getBaseType() instanceof Int16);
assertTrue(unionTypes.get(1) instanceof Int32);
QName testleafTypeQName = type.getQName();
assertEquals(bazNS, testleafTypeQName.getNamespace());
assertEquals(bazRev, testleafTypeQName.getRevision());
- assertEquals("baz", testleafTypeQName.getPrefix());
assertEquals("union1", testleafTypeQName.getLocalName());
assertNull(type.getUnits());
assertNull(type.getDefaultValue());
QName typeBaseQName = typeBase.getQName();
assertEquals(bazNS, typeBaseQName.getNamespace());
assertEquals(bazRev, typeBaseQName.getRevision());
- assertEquals("baz", typeBaseQName.getPrefix());
assertEquals("union2", typeBaseQName.getLocalName());
assertNull(typeBase.getUnits());
assertNull(typeBase.getDefaultValue());
QName uniontType1QName = unionType1.getQName();
assertEquals(barNS, uniontType1QName.getNamespace());
assertEquals(barRev, uniontType1QName.getRevision());
- assertEquals("bar", uniontType1QName.getPrefix());
assertEquals("nested-union2", uniontType1QName.getLocalName());
assertNull(unionType1.getUnits());
assertNull(unionType1.getDefaultValue());
QName myUnionExtQName = myUnionExt.getQName();
assertEquals(barNS, myUnionExtQName.getNamespace());
assertEquals(barRev, myUnionExtQName.getRevision());
- assertEquals("bar", myUnionExtQName.getPrefix());
assertEquals("my-union-ext", myUnionExtQName.getLocalName());
assertNull(myUnionExt.getUnits());
assertNull(myUnionExt.getDefaultValue());
QName myUnionQName = myUnion.getQName();
assertEquals(barNS, myUnionQName.getNamespace());
assertEquals(barRev, myUnionQName.getRevision());
- assertEquals("bar", myUnionQName.getPrefix());
assertEquals("my-union", myUnionQName.getLocalName());
assertNull(myUnion.getUnits());
assertNull(myUnion.getDefaultValue());
QName int16ExtQName = int16Ext.getQName();
assertEquals(barNS, int16ExtQName.getNamespace());
assertEquals(barRev, int16ExtQName.getRevision());
- assertEquals("bar", int16ExtQName.getPrefix());
assertEquals("int16", int16ExtQName.getLocalName());
assertNull(int16Ext.getUnits());
assertNull(int16Ext.getDefaultValue());
List<RangeConstraint> ranges = int16Ext.getRangeConstraints();
assertEquals(1, ranges.size());
RangeConstraint range = ranges.get(0);
- assertEquals(1L, range.getMin());
- assertEquals(100L, range.getMax());
+ assertEquals(BigInteger.ONE, range.getMin());
+ assertEquals(BigInteger.valueOf(100), range.getMax());
assertTrue(int16Ext.getBaseType() instanceof Int16);
}
public void testChoice() {
Module foo = TestUtils.findModule(modules, "foo");
ContainerSchemaNode transfer = (ContainerSchemaNode) foo.getDataChildByName("transfer");
- ChoiceNode how = (ChoiceNode) transfer.getDataChildByName("how");
+ ChoiceSchemaNode how = (ChoiceSchemaNode) transfer.getDataChildByName("how");
Set<ChoiceCaseNode> cases = how.getCases();
assertEquals(5, cases.size());
ChoiceCaseNode input = null;
assertEquals("system/user ref", dev.getReference());
List<QName> path = new ArrayList<>();
- path.add(new QName(barNS, barRev, "br", "interfaces"));
- path.add(new QName(barNS, barRev, "br", "ifEntry"));
- SchemaPath expectedPath = new SchemaPath(path, true);
+ path.add(QName.create(barNS, barRev, "interfaces"));
+ path.add(QName.create(barNS, barRev, "ifEntry"));
+ SchemaPath expectedPath = SchemaPath.create(path, true);
assertEquals(expectedPath, dev.getTargetPath());
assertEquals(Deviate.ADD, dev.getDeviate());
assertEquals(1, extensions.size());
ExtensionDefinition extension = extensions.get(0);
assertEquals("name", extension.getArgument());
+ assertEquals("Takes as argument a name string. Makes the code generator use the given name in the #define.",
+ extension.getDescription());
assertTrue(extension.isYinElement());
}
NotificationDefinition notification = notifications.iterator().next();
// test SchemaNode args
- QName expectedQName = new QName(bazNS, bazRev, expectedPrefix, "event");
+ QName expectedQName = QName.create(bazNS, bazRev, "event");
assertEquals(expectedQName, notification.getQName());
SchemaPath expectedPath = TestUtils.createPath(true, bazNS, bazRev, expectedPrefix, "event");
assertEquals(expectedPath, notification.getPath());
assertEquals(barNS, int32TypedefQName.getNamespace());
assertEquals(barRev, int32TypedefQName.getRevision());
- assertEquals("bar", int32TypedefQName.getPrefix());
assertEquals("int32-ext1", int32TypedefQName.getLocalName());
SchemaPath typeSchemaPath = int32ext1.getPath();
- List<QName> typePath = typeSchemaPath.getPath();
- assertEquals(1, typePath.size());
- assertEquals(int32TypedefQName, typePath.get(0));
+ Iterable<QName> typePath = typeSchemaPath.getPathFromRoot();
+ Iterator<QName> typePathIt = typePath.iterator();
+ assertEquals(int32TypedefQName, typePathIt.next());
+ assertFalse(typePathIt.hasNext());
// int32-ext1/int32
Int32 int32 = (Int32) int32ext1.getBaseType();
assertEquals(barNS, myDecTypeQName.getNamespace());
assertEquals(barRev, myDecTypeQName.getRevision());
- assertEquals("bar", myDecTypeQName.getPrefix());
assertEquals("my-decimal-type", myDecTypeQName.getLocalName());
SchemaPath typeSchemaPath = myDecType.getPath();
- List<QName> typePath = typeSchemaPath.getPath();
- assertEquals(1, typePath.size());
- assertEquals(myDecTypeQName, typePath.get(0));
+ Iterable<QName> typePath = typeSchemaPath.getPathFromRoot();
+ Iterator<QName> typePathIt = typePath.iterator();
+ assertEquals(myDecTypeQName, typePathIt.next());
+ assertFalse(typePathIt.hasNext());
// my-base-int32-type/int32
Decimal64 dec64 = (Decimal64) myDecType.getBaseType();
assertEquals(URI.create("urn:ietf:params:xml:ns:yang:1"), dec64QName.getNamespace());
assertNull(dec64QName.getRevision());
- assertEquals("", dec64QName.getPrefix());
assertEquals("decimal64", dec64QName.getLocalName());
SchemaPath dec64SchemaPath = dec64.getPath();
- List<QName> dec64Path = dec64SchemaPath.getPath();
- assertEquals(2, dec64Path.size());
- assertEquals(myDecTypeQName, dec64Path.get(0));
- assertEquals(dec64QName, dec64Path.get(1));
+ Iterable<QName> dec64Path = dec64SchemaPath.getPathFromRoot();
+ Iterator<QName> dec64PathIt = dec64Path.iterator();
+ assertEquals(myDecTypeQName, dec64PathIt.next());
+ assertEquals(dec64QName, dec64PathIt.next());
+ assertFalse(dec64PathIt.hasNext());
}
@Test
public void testParseMethod1() throws Exception {
File yangFile = new File(getClass().getResource("/parse-methods/m1.yang").toURI());
File dependenciesDir = new File(getClass().getResource("/parse-methods").toURI());
- YangModelParser parser = new YangParserImpl();
- modules = parser.parseYangModels(yangFile, dependenciesDir);
+ YangContextParser parser = new YangParserImpl();
+ modules = parser.parseFile(yangFile, dependenciesDir).getModules();
assertEquals(6, modules.size());
}
public void testParseMethod2() throws Exception {
File yangFile = new File(getClass().getResource("/parse-methods/m1.yang").toURI());
File dependenciesDir = new File(getClass().getResource("/parse-methods/dependencies").toURI());
- YangModelParser parser = new YangParserImpl();
- modules = parser.parseYangModels(yangFile, dependenciesDir);
+ YangContextParser parser = new YangParserImpl();
+ modules = parser.parseFile(yangFile, dependenciesDir).getModules();
assertEquals(6, modules.size());
}
// Correct order: m2, m4, m6, m8, m7, m6, m3, m1
File yangFile = new File(getClass().getResource("/sorting-test/m1.yang").toURI());
File dependenciesDir = new File(getClass().getResource("/sorting-test").toURI());
- YangModelParser parser = new YangParserImpl();
- modules = parser.parseYangModels(yangFile, dependenciesDir);
- SchemaContext ctx = new SchemaContextImpl(modules, Collections.<ModuleIdentifier, String>emptyMap());
+ YangContextParser parser = new YangParserImpl();
+ modules = parser.parseFile(yangFile, dependenciesDir).getModules();
+ SchemaContext ctx = new SchemaContextImpl(modules, Collections.emptyMap());
checkOrder(modules);
assertSetEquals(modules, ctx.getModules());
for (String fileName : fileList) {
testFiles.add(new File(testDir, fileName));
}
- Set<Module> newModules = parser.parseYangModels(testFiles);
+ Set<Module> newModules = parser.parseFiles(testFiles).getModules();
assertSetEquals(newModules, modules);
- ctx = new SchemaContextImpl(newModules, Collections.<ModuleIdentifier, String>emptyMap());
+ ctx = new SchemaContextImpl(newModules, Collections.emptyMap());
assertSetEquals(newModules, ctx.getModules());
// ##########
- newModules = parser.parseYangModels(testFiles, null);
+ newModules = parser.parseFiles(testFiles, null).getModules();
assertSetEquals(newModules, modules);
- ctx = new SchemaContextImpl(newModules, Collections.<ModuleIdentifier, String>emptyMap());
+ ctx = new SchemaContextImpl(newModules, Collections.emptyMap());
assertSetEquals(newModules, ctx.getModules());
// ##########
List<InputStream> streams = new ArrayList<>();
for (File f : testFiles) {
streams.add(new FileInputStream(f));
}
- newModules = parser.parseYangModelsFromStreams(streams);
+ newModules = parser.parseSources(BuilderUtils.filesToByteSources(testFiles)).getModules();
assertSetEquals(newModules, modules);
- ctx = new SchemaContextImpl(newModules, Collections.<ModuleIdentifier, String>emptyMap());
+ ctx = new SchemaContextImpl(newModules, Collections.emptyMap());
assertSetEquals(newModules, ctx.getModules());
// ##########
streams.clear();
for (File f : testFiles) {
streams.add(new FileInputStream(f));
}
- newModules = parser.parseYangModelsFromStreams(streams, null);
- assertSetEquals(newModules, modules);
- ctx = new SchemaContextImpl(newModules, Collections.<ModuleIdentifier, String>emptyMap());
- assertSetEquals(newModules, ctx.getModules());
- // ##########
- Map<File, Module> mapped = parser.parseYangModelsMapped(testFiles);
- newModules = new LinkedHashSet<>(mapped.values());
+ newModules = parser.parseSources(BuilderUtils.filesToByteSources(testFiles), null).getModules();
assertSetEquals(newModules, modules);
- ctx = new SchemaContextImpl(newModules, Collections.<ModuleIdentifier, String>emptyMap());
- assertSetEquals(newModules, ctx.getModules());
- // ##########
- streams.clear();
- for (File f : testFiles) {
- streams.add(new FileInputStream(f));
- }
- Map<InputStream, Module> mappedStreams = parser.parseYangModelsFromStreamsMapped(streams);
- newModules = new LinkedHashSet<>(mappedStreams.values());
- assertSetEquals(newModules, modules);
- ctx = new SchemaContextImpl(newModules, Collections.<ModuleIdentifier, String>emptyMap());
+ ctx = new SchemaContextImpl(newModules, Collections.emptyMap());
assertSetEquals(newModules, ctx.getModules());
}
- private void checkOrder(Collection<Module> modules) {
+ private static void checkOrder(final Collection<Module> modules) {
Iterator<Module> it = modules.iterator();
Module m = it.next();
assertEquals("m2", m.getName());
assertEquals("m1", m.getName());
}
- private void assertSetEquals(Set<Module> s1, Set<Module> s2) {
+ private static void assertSetEquals(final Set<Module> s1, final Set<Module> s2) {
assertEquals(s1, s2);
Iterator<Module> it = s1.iterator();
for (Module m : s2) {
}
@Test
- public void testSubmodules() throws URISyntaxException {
- URI yangFilePath = getClass().getResource("/submodule-test/subfoo.yang").toURI();
- URI directoryPath = getClass().getResource("/model").toURI();
-
- File directory = new File(directoryPath);
- File yangFile = new File(yangFilePath);
-
- Set<Module> modules = new YangParserImpl().parseYangModels(yangFile, directory);
- assertEquals(3, modules.size());
-
+ public void testSubmodules() throws Exception {
Module foo = TestUtils.findModule(modules, "foo");
DataSchemaNode id = foo.getDataChildByName("id");
assertEquals(2, foo.getAugmentations().size());
}
+ @Test
+ public void unknownStatementInSubmoduleHeaderTest() throws IOException, URISyntaxException {
+
+ File yang = new File(getClass().getResource("/yang-grammar-test/submodule-header-extension.yang").toURI());
+
+ try {
+ YangParserImpl.getInstance().parseFile(yang, yang.getParentFile());
+ } catch (YangSyntaxErrorException | YangParseException e) {
+ e.printStackTrace();
+ fail("YangSyntaxErrorException or YangParseException should not be thrown");
+ }
+
+ }
+
+ @Test
+ public void unknownStatementBetweenRevisionsTest() throws IOException, URISyntaxException {
+
+ File yangModul = new File(getClass().getResource("/yang-grammar-test/revisions-extension.yang").toURI());
+ File yangSubmodul = new File(getClass().getResource("/yang-grammar-test/submodule-header-extension.yang")
+ .toURI());
+
+ List<File> yangs = new ArrayList<>();
+ yangs.add(yangModul);
+ yangs.add(yangSubmodul);
+
+ try {
+ YangParserImpl.getInstance().parseFiles(yangs);
+ } catch (YangParseException e) {
+ e.printStackTrace();
+ fail("YangParseException should not be thrown");
+ }
+ }
+
+ @Test
+ public void unknownStatementsInStatementsTest() throws IOException, URISyntaxException {
+ File yangModule1 = new File(getClass().getResource("/yang-grammar-test/stmtsep-in-statements.yang").toURI());
+ File yangModule2 = new File(getClass().getResource("/yang-grammar-test/stmtsep-in-statements2.yang").toURI());
+ File yangSubModule = new File(getClass().getResource("/yang-grammar-test/stmtsep-in-statements-sub.yang").toURI());
+
+ List<File> yangs = new ArrayList<>();
+ yangs.add(yangModule1);
+ yangs.add(yangModule2);
+ yangs.add(yangSubModule);
+
+ try {
+ YangParserImpl.getInstance().parseFiles(yangs);
+ } catch (YangParseException e) {
+ e.printStackTrace();
+ fail("YangParseException should not be thrown");
+ }
+ }
}