import java.io.FileNotFoundException;
import java.net.URI;
import java.text.DateFormat;
+import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import org.opendaylight.controller.yang.model.util.ExtendedType;
import org.opendaylight.controller.yang.model.util.Int16;
import org.opendaylight.controller.yang.model.util.Int32;
+import org.opendaylight.controller.yang.model.util.Int8;
import org.opendaylight.controller.yang.model.util.Leafref;
import org.opendaylight.controller.yang.model.util.StringType;
import org.opendaylight.controller.yang.model.util.Uint32;
import org.opendaylight.controller.yang.model.util.UnionType;
public class YangParserTest {
+ private final DateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
+
private Set<Module> modules;
@Before
assertTrue(ifMtu.getType() instanceof Int32);
}
+ @Test
+ public void testParseLeaf() throws ParseException {
+ Module test = TestUtils.findModule(modules, "types2");
+
+ // leaf if-name
+ LeafSchemaNode ifName = (LeafSchemaNode) test
+ .getDataChildByName("if-name");
+ Leafref ifNameType = (Leafref)ifName.getType();
+ QName qname = ifNameType.getQName();
+
+ URI baseYangTypeNS = URI.create("urn:ietf:params:xml:ns:yang:1");
+ assertEquals(baseYangTypeNS, qname.getNamespace());
+ assertNull(qname.getRevision());
+ assertEquals("", qname.getPrefix());
+ assertEquals("leafref", qname.getLocalName());
+
+ // leaf name
+ LeafSchemaNode name = (LeafSchemaNode) test
+ .getDataChildByName("name");
+ StringType nameType = (StringType)name.getType();
+ QName nameQName = nameType.getQName();
+
+ assertEquals(baseYangTypeNS, nameQName.getNamespace());
+ assertNull(nameQName.getRevision());
+ assertEquals("", nameQName.getPrefix());
+ assertEquals("string", nameQName.getLocalName());
+
+ // leaf count
+ LeafSchemaNode count = (LeafSchemaNode) test
+ .getDataChildByName("count");
+ ExtendedType countType = (ExtendedType)count.getType();
+ QName countTypeQName = countType.getQName();
+
+ URI expectedNS = URI.create("urn:simple.types.data.demo");
+ Date expectedDate = simpleDateFormat.parse("2013-02-27");
+ assertEquals(expectedNS, countTypeQName.getNamespace());
+ assertEquals(expectedDate, countTypeQName.getRevision());
+ assertEquals("t2", countTypeQName.getPrefix());
+ assertEquals("int8", countTypeQName.getLocalName());
+
+ Int8 countTypeBase = (Int8)countType.getBaseType();
+ QName countTypeBaseQName = countTypeBase.getQName();
+
+ assertEquals(baseYangTypeNS, countTypeBaseQName.getNamespace());
+ assertNull(countTypeBaseQName.getRevision());
+ assertEquals("", countTypeBaseQName.getPrefix());
+ assertEquals("int8", countTypeBaseQName.getLocalName());
+ }
+
@Test
public void testAugmentResolving() {
// testfile1
ExtendedType baseType = (ExtendedType) testleafType.getBaseType();
assertEquals("my-base-int32-type", baseType.getQName().getLocalName());
- Int32 int32base = (Int32) baseType.getBaseType();
- List<RangeConstraint> ranges = int32base.getRangeStatements();
+ ExtendedType int32Type = (ExtendedType) baseType.getBaseType();
+ Int32 int32TypeBase = (Int32)int32Type.getBaseType();
+ QName qname = int32TypeBase.getQName();
+ assertEquals(URI.create("urn:ietf:params:xml:ns:yang:1"), qname.getNamespace());
+ assertNull(qname.getRevision());
+ assertEquals("", qname.getPrefix());
+ assertEquals("int32", qname.getLocalName());
+ List<RangeConstraint> ranges = int32Type.getRanges();
assertEquals(1, ranges.size());
RangeConstraint range = ranges.get(0);
assertEquals(2L, range.getMin());
UnionType unionBase = (UnionType) baseType.getBaseType();
List<TypeDefinition<?>> unionTypes = unionBase.getTypes();
- Int16 unionType1 = (Int16) unionTypes.get(0);
- List<RangeConstraint> ranges = unionType1.getRangeStatements();
+ ExtendedType unionType1 = (ExtendedType) unionTypes.get(0);
+ List<RangeConstraint> ranges = unionType1.getRanges();
assertEquals(1, ranges.size());
RangeConstraint range = ranges.get(0);
assertEquals(1L, range.getMin());
assertEquals(100L, range.getMax());
- assertTrue(unionTypes.get(0) instanceof Int16);
+ assertTrue(unionType1.getBaseType() instanceof Int16);
assertTrue(unionTypes.get(1) instanceof Int32);
}
.getBaseType();
List<TypeDefinition<?>> extendedTargetTypes = extendedTargetUnion
.getTypes();
- assertTrue(extendedTargetTypes.get(0) instanceof Int16);
+ assertTrue(extendedTargetTypes.get(0).getBaseType() instanceof Int16);
assertTrue(extendedTargetTypes.get(1) instanceof Int32);
- Int16 int16 = (Int16) extendedTargetTypes.get(0);
- List<RangeConstraint> ranges = int16.getRangeStatements();
+ ExtendedType int16 = (ExtendedType) extendedTargetTypes.get(0);
+ assertTrue(int16.getBaseType() instanceof Int16);
+ List<RangeConstraint> ranges = int16.getRanges();
assertEquals(1, ranges.size());
RangeConstraint range = ranges.get(0);
assertEquals(1L, range.getMin());
UnionType myUnionBase = (UnionType) myUnion.getBaseType();
List<TypeDefinition<?>> myUnionBaseTypes = myUnionBase.getTypes();
assertEquals(2, myUnionBaseTypes.size());
- assertTrue(myUnionBaseTypes.get(0) instanceof Int16);
+ assertTrue(myUnionBaseTypes.get(0).getBaseType() instanceof Int16);
assertTrue(myUnionBaseTypes.get(1) instanceof Int32);
- Int16 int16 = (Int16) myUnionBaseTypes.get(0);
- List<RangeConstraint> ranges = int16.getRangeStatements();
+ ExtendedType int16 = (ExtendedType) myUnionBaseTypes.get(0);
+ List<RangeConstraint> ranges = int16.getRanges();
assertEquals(1, ranges.size());
RangeConstraint range = ranges.get(0);
assertEquals(1L, range.getMin());
assertNotNull(refineContainer);
Set<MustDefinition> mustConstraints = refineContainer.getConstraints()
.getMustConstraints();
- assertEquals(1, mustConstraints.size());
- MustDefinition must = mustConstraints.iterator().next();
- assertEquals("must-condition", must.toString());
- assertEquals("An error message test", must.getErrorMessage());
- assertEquals(("An error app tag test"), must.getErrorAppTag());
+ assertTrue(mustConstraints.isEmpty());
assertEquals("description of port defined by refine",
refineContainer.getDescription());
assertEquals("port reference added by refine",
@Test
public void testAugmentNodesTypesSchemaPath() throws Exception {
- final DateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
Module testModule = TestUtils.findModule(modules, "types1");
Set<AugmentationSchema> augments = testModule.getAugmentations();
assertEquals(1, augments.size());
assertEquals(q3, higherLayerTypePath.get(3));
}
+ @Test
+ public void testTypePath() throws ParseException {
+ Module test = TestUtils.findModule(modules, "types2");
+ Set<TypeDefinition<?>> types = test.getTypeDefinitions();
+
+ // my-base-int32-type
+ ExtendedType int32Typedef = (ExtendedType)TestUtils.findTypedef(types, "my-base-int32-type");
+ QName int32TypedefQName = int32Typedef.getQName();
+
+ URI expectedNS = URI.create("urn:simple.types.data.demo");
+ Date expectedDate = simpleDateFormat.parse("2013-02-27");
+ assertEquals(expectedNS, int32TypedefQName.getNamespace());
+ assertEquals(expectedDate, int32TypedefQName.getRevision());
+ assertEquals("t2", int32TypedefQName.getPrefix());
+ assertEquals("my-base-int32-type", int32TypedefQName.getLocalName());
+
+ SchemaPath typeSchemaPath = int32Typedef.getPath();
+ List<QName> typePath = typeSchemaPath.getPath();
+ assertEquals(1, typePath.size());
+ assertEquals(int32TypedefQName, typePath.get(0));
+
+ // my-base-int32-type/int32
+ ExtendedType int32Ext = (ExtendedType)int32Typedef.getBaseType();
+ QName int32ExtQName = int32Ext.getQName();
+
+ assertEquals(expectedNS, int32ExtQName.getNamespace());
+ assertEquals(expectedDate, int32ExtQName.getRevision());
+ assertEquals("t2", int32ExtQName.getPrefix());
+ assertEquals("int32", int32ExtQName.getLocalName());
+
+ SchemaPath int32ExtSchemaPath = int32Ext.getPath();
+ List<QName> int32ExtPath = int32ExtSchemaPath.getPath();
+ assertEquals(2, int32ExtPath.size());
+ assertEquals(int32TypedefQName, int32ExtPath.get(0));
+ assertEquals(int32ExtQName, int32ExtPath.get(1));
+
+ // my-base-int32-type/int32/int32
+ Int32 int32 = (Int32)int32Ext.getBaseType();
+ QName int32QName = int32.getQName();
+ assertEquals(URI.create("urn:ietf:params:xml:ns:yang:1"), int32QName.getNamespace());
+ assertNull(int32QName.getRevision());
+ assertEquals("", int32QName.getPrefix());
+ assertEquals("int32", int32QName.getLocalName());
+
+ SchemaPath int32SchemaPath = int32.getPath();
+ List<QName> int32Path = int32SchemaPath.getPath();
+ assertEquals(3, int32Path.size());
+ assertEquals(int32TypedefQName, int32Path.get(0));
+ assertEquals(int32ExtQName, int32Path.get(1));
+ assertEquals(int32QName, int32Path.get(2));
+ }
+
+ @Test
+ public void testTypePath2() throws ParseException {
+ Module test = TestUtils.findModule(modules, "types2");
+ Set<TypeDefinition<?>> types = test.getTypeDefinitions();
+
+ // my-base-int32-type
+ ExtendedType myDecType = (ExtendedType)TestUtils.findTypedef(types, "my-decimal-type");
+ QName myDecTypeQName = myDecType.getQName();
+
+ URI expectedNS = URI.create("urn:simple.types.data.demo");
+ Date expectedDate = simpleDateFormat.parse("2013-02-27");
+ assertEquals(expectedNS, myDecTypeQName.getNamespace());
+ assertEquals(expectedDate, myDecTypeQName.getRevision());
+ assertEquals("t2", 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));
+
+ // my-base-int32-type/int32
+ Decimal64 dec64 = (Decimal64)myDecType.getBaseType();
+ QName dec64QName = dec64.getQName();
+
+ 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));
+ }
+
}
Code Review / controller.git / blobdiff