Code Review / yangtools.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
Cleanup DocumentedNode
[yangtools.git] / yang / yang-parser-impl / src / test / java / org / opendaylight / yangtools / yang / stmt / EffectiveStatementTypeTest.java
diff --git a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/EffectiveStatementTypeTest.java b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/EffectiveStatementTypeTest.java
index df387ffb254e4d5b3c6a64341e88857780c4cdcb..dc9072d5f7923040708de5e015613b497e29472c 100644 (file)
--- a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/EffectiveStatementTypeTest.java
+++ b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/EffectiveStatementTypeTest.java
@@ -24,6 +24,7 @@ import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.Module;
 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.Status;
 import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
 import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
@@ -83,11 +84,11 @@ public class EffectiveStatementTypeTest {
         assertNull(binaryEff.getDefaultValue());
         assertEquals("binary", binaryEff.getQName().getLocalName());
         assertFalse(binaryEff.getLengthConstraint().isPresent());
-        assertEquals("CURRENT", binaryEff.getStatus().toString());
+        assertEquals(Status.CURRENT, binaryEff.getStatus());
         assertEquals("binary", binaryEff.getPath().getPathFromRoot().iterator().next().getLocalName());
         assertNotNull(binaryEff.getUnknownSchemaNodes());
-        assertNull(binaryEff.getDescription());
-        assertNull(binaryEff.getReference());
+        assertFalse(binaryEff.getDescription().isPresent());
+        assertFalse(binaryEff.getReference().isPresent());
     }
 
     @Test
@@ -108,9 +109,9 @@ public class EffectiveStatementTypeTest {
         assertEquals("bits", bitsEff.getQName().getLocalName());
         assertEquals("bits", bitsEff.getPath().getLastComponent().getLocalName());
         assertNotNull(bitsEff.getUnknownSchemaNodes());
-        assertNull(bitsEff.getDescription());
-        assertNull(bitsEff.getReference());
-        assertEquals("CURRENT", bitsEff.getStatus().toString());
+        assertFalse(bitsEff.getDescription().isPresent());
+        assertFalse(bitsEff.getReference().isPresent());
+        assertEquals(Status.CURRENT, bitsEff.getStatus());
         assertNull(bitsEff.getUnits());
         assertNotNull(bitsEff.toString());
         assertNotNull(bitsEff.hashCode());
@@ -122,9 +123,9 @@ public class EffectiveStatementTypeTest {
 
         assertNotNull(bitEff.getPath());
         assertNotNull(bitEff.getUnknownSchemaNodes());
-        assertEquals("test bit", bitEff.getDescription());
-        assertEquals("test bit ref", bitEff.getReference());
-        assertEquals("CURRENT", bitEff.getStatus().toString());
+        assertEquals(Optional.of("test bit"), bitEff.getDescription());
+        assertEquals(Optional.of("test bit ref"), bitEff.getReference());
+        assertEquals(Status.CURRENT, bitEff.getStatus());
         assertNotNull(bitEff.hashCode());
         assertFalse(bitEff.equals(null));
         assertFalse(bitEff.equals("test"));
@@ -149,9 +150,9 @@ public class EffectiveStatementTypeTest {
         assertEquals("boolean", booleanEff.getQName().getLocalName());
         assertNull(booleanEff.getPath().getParent().getParent());
         assertNotNull(booleanEff.getUnknownSchemaNodes());
-        assertNull(booleanEff.getDescription());
-        assertNull(booleanEff.getReference());
-        assertEquals("CURRENT", booleanEff.getStatus().toString());
+        assertFalse(booleanEff.getDescription().isPresent());
+        assertFalse(booleanEff.getReference().isPresent());
+        assertEquals(Status.CURRENT, booleanEff.getStatus());
         assertNotNull(booleanEff.toString());
     }
 
@@ -172,9 +173,9 @@ public class EffectiveStatementTypeTest {
         // FIXME: The yang model api is wrong: description/reference/status are not allowed under 'type', how come we
         // parse it?
         // allowed under 'type', how come we parse it?
-        assertNull(decimal64Eff.getDescription());
-        assertNull(decimal64Eff.getReference());
-        assertEquals("CURRENT", decimal64Eff.getStatus().toString());
+        assertFalse(decimal64Eff.getDescription().isPresent());
+        assertFalse(decimal64Eff.getReference().isPresent());
+        assertEquals(Status.CURRENT, decimal64Eff.getStatus());
 
         assertEquals(3, decimal64Eff.getRangeConstraints().size());
         assertNotNull(decimal64Eff.toString());
@@ -200,8 +201,8 @@ public class EffectiveStatementTypeTest {
         assertEquals("empty", emptyEff.getQName().getLocalName());
         assertNull(emptyEff.getPath().getParent().getParent());
         assertNotNull(emptyEff.getUnknownSchemaNodes());
-        assertNull(emptyEff.getDescription());
-        assertNull(emptyEff.getReference());
+        assertFalse(emptyEff.getDescription().isPresent());
+        assertFalse(emptyEff.getReference().isPresent());
         assertEquals("CURRENT", emptyEff.getStatus().toString());
         assertNotNull(emptyEff.toString());
     }
@@ -223,9 +224,9 @@ public class EffectiveStatementTypeTest {
         assertEquals(3, enumSpecEff.getValues().size());
         assertNull(enumSpecEff.getBaseType());
         assertNotNull(enumSpecEff.getUnknownSchemaNodes());
-        assertEquals("CURRENT", enumSpecEff.getStatus().toString());
-        assertNull(enumSpecEff.getDescription());
-        assertNull(enumSpecEff.getReference());
+        assertEquals(Status.CURRENT, enumSpecEff.getStatus());
+        assertFalse(enumSpecEff.getDescription().isPresent());
+        assertFalse(enumSpecEff.getReference().isPresent());
         assertNull(enumSpecEff.getUnits());
         assertNotNull(enumSpecEff.toString());
         assertNotNull(enumSpecEff.hashCode());
@@ -235,9 +236,9 @@ public class EffectiveStatementTypeTest {
 
         assertEquals("zero", enumEff.getName());
         assertNotNull(enumEff.getUnknownSchemaNodes());
-        assertEquals("test enum", enumEff.getDescription());
-        assertEquals("test enum ref", enumEff.getReference());
-        assertEquals("CURRENT", enumEff.getStatus().toString());
+        assertEquals(Optional.of("test enum"), enumEff.getDescription());
+        assertEquals(Optional.of("test enum ref"), enumEff.getReference());
+        assertEquals(Status.CURRENT, enumEff.getStatus());
         assertEquals(0, enumEff.getValue());
     }
 
@@ -255,10 +256,10 @@ public class EffectiveStatementTypeTest {
         assertEquals("identityref", identityRefEff.getPath().getLastComponent().getLocalName());
         assertNull(identityRefEff.getBaseType());
         assertNotNull(identityRefEff.getUnknownSchemaNodes());
-        assertEquals("CURRENT", identityRefEff.getStatus().toString());
+        assertEquals(Status.CURRENT, identityRefEff.getStatus());
         assertEquals("test-identity", identityRefEff.getIdentity().getQName().getLocalName());
-        assertNull(identityRefEff.getDescription());
-        assertNull(identityRefEff.getReference());
+        assertFalse(identityRefEff.getDescription().isPresent());
+        assertFalse(identityRefEff.getReference().isPresent());
         assertNotNull(identityRefEff.toString());
 
         // FIXME: the model is wrong, but we accept units in 'type' statement
@@ -281,10 +282,10 @@ public class EffectiveStatementTypeTest {
         assertNull(instanceIdentEff.getBaseType());
         assertNull(instanceIdentEff.getDefaultValue());
         assertNotNull(instanceIdentEff.getUnknownSchemaNodes());
-        assertNull(instanceIdentEff.getDescription());
-        assertNull(instanceIdentEff.getReference());
+        assertFalse(instanceIdentEff.getDescription().isPresent());
+        assertFalse(instanceIdentEff.getReference().isPresent());
         assertNull(instanceIdentEff.getUnits());
-        assertEquals("CURRENT", instanceIdentEff.getStatus().toString());
+        assertEquals(Status.CURRENT, instanceIdentEff.getStatus());
         assertNotNull(instanceIdentEff.hashCode());
         assertFalse(instanceIdentEff.equals(null));
         assertFalse(instanceIdentEff.equals("test"));
@@ -306,11 +307,11 @@ public class EffectiveStatementTypeTest {
         assertNull(leafrefEff.getDefaultValue());
         assertNotNull(leafrefEff.toString());
         assertEquals("leafref", leafrefEff.getQName().getLocalName());
-        assertEquals("CURRENT", leafrefEff.getStatus().toString());
+        assertEquals(Status.CURRENT, leafrefEff.getStatus());
         assertNotNull(leafrefEff.getUnknownSchemaNodes());
         assertEquals("leafref", leafrefEff.getPath().getLastComponent().getLocalName());
-        assertNull(leafrefEff.getDescription());
-        assertNull(leafrefEff.getReference());
+        assertFalse(leafrefEff.getDescription().isPresent());
+        assertFalse(leafrefEff.getReference().isPresent());
         assertNotNull(leafrefEff.hashCode());
         assertFalse(leafrefEff.equals(null));
         assertFalse(leafrefEff.equals("test"));
@@ -383,8 +384,8 @@ public class EffectiveStatementTypeTest {
         assertNull(unionEff.getBaseType());
         assertNull(unionEff.getUnits());
         assertNull(unionEff.getDefaultValue());
-        assertNull(unionEff.getDescription());
-        assertNull(unionEff.getReference());
+        assertFalse(unionEff.getDescription().isPresent());
+        assertFalse(unionEff.getReference().isPresent());
         assertNotNull(unionEff.toString());
         assertNotNull(unionEff.hashCode());
         assertFalse(unionEff.equals(null));
@@ -405,8 +406,8 @@ public class EffectiveStatementTypeTest {
         final Range<Integer> span = lengthConstraint.getAllowedRanges().span();
         assertEquals(1, span.lowerEndpoint().intValue());
         assertEquals(255, span.upperEndpoint().intValue());
-        assertNull(lengthConstraint.getReference());
-        assertNull(lengthConstraint.getDescription());
+        assertFalse(lengthConstraint.getReference().isPresent());
+        assertFalse(lengthConstraint.getDescription().isPresent());
         assertFalse(lengthConstraint.getErrorMessage().isPresent());
         assertFalse(lengthConstraint.getErrorAppTag().isPresent());
         assertNotNull(lengthConstraint.toString());
@@ -438,8 +439,8 @@ public class EffectiveStatementTypeTest {
                 ((StringTypeDefinition) currentLeaf.getType()).getPatternConstraints().get(0);
 
         assertEquals("^[0-9a-fA-F]*$", patternConstraint.getRegularExpression());
-        assertNull(patternConstraint.getReference());
-        assertNull(patternConstraint.getDescription());
+        assertFalse(patternConstraint.getReference().isPresent());
+        assertFalse(patternConstraint.getDescription().isPresent());
         assertEquals(Optional.of("Supplied value does not match the regular expression ^[0-9a-fA-F]*$."),
             patternConstraint.getErrorMessage());
         assertEquals(Optional.of("invalid-regular-expression"), patternConstraint.getErrorAppTag());
@@ -460,13 +461,13 @@ public class EffectiveStatementTypeTest {
                 .getTypeDefinition();
 
         assertEquals("string", stringEff.getQName().getLocalName());
-        assertEquals("CURRENT", stringEff.getStatus().toString());
+        assertEquals(Status.CURRENT, stringEff.getStatus());
         assertNull(stringEff.getUnits());
         assertNull(stringEff.getDefaultValue());
         assertNotNull(stringEff.getUnknownSchemaNodes());
         assertNull(stringEff.getBaseType());
-        assertNull(stringEff.getDescription());
-        assertNull(stringEff.getReference());
+        assertFalse(stringEff.getDescription().isPresent());
+        assertFalse(stringEff.getReference().isPresent());
         assertNotNull(stringEff.toString());
         assertNotNull(stringEff.hashCode());
         assertFalse(stringEff.equals(null));
OpenDaylight YANG Tools