yang/yang-parser-rfc7950/src/test/java/org/opendaylight/yangtools/yang/stmt/EffectiveStatementTypeTest.java

   1 /*
   2  * Copyright (c) 2016 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.yangtools.yang.stmt;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertFalse;
  12 import static org.junit.Assert.assertNotNull;
  13 import static org.junit.Assert.assertNull;
  14 import static org.junit.Assert.assertTrue;
  15 import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
  16
  17 import com.google.common.collect.Range;
  18 import java.util.Iterator;
  19 import java.util.List;
  20 import java.util.Optional;
  21 import org.junit.AfterClass;
  22 import org.junit.BeforeClass;
  23 import org.junit.Test;
  24 import org.opendaylight.yangtools.yang.common.QName;
  25 import org.opendaylight.yangtools.yang.common.Uint32;
  26 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
  27 import org.opendaylight.yangtools.yang.model.api.Module;
  28 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  29 import org.opendaylight.yangtools.yang.model.api.Status;
  30 import org.opendaylight.yangtools.yang.model.api.stmt.LeafEffectiveStatement;
  31 import org.opendaylight.yangtools.yang.model.api.stmt.TypeDefinitionAware;
  32 import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
  33 import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
  34 import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
  35 import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition.Bit;
  36 import org.opendaylight.yangtools.yang.model.api.type.BooleanTypeDefinition;
  37 import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
  38 import org.opendaylight.yangtools.yang.model.api.type.EmptyTypeDefinition;
  39 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
  40 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair;
  41 import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
  42 import org.opendaylight.yangtools.yang.model.api.type.InstanceIdentifierTypeDefinition;
  43 import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
  44 import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
  45 import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
  46 import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
  47 import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
  48 import org.opendaylight.yangtools.yang.parser.rfc7950.reactor.RFC7950Reactors;
  49 import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
  50
  51 public class EffectiveStatementTypeTest {
  52     private static SchemaContext effectiveSchemaContext;
  53     private static Module types;
  54
  55     private LeafSchemaNode currentLeaf;
  56
  57     @BeforeClass
  58     public static void setup() throws ReactorException {
  59         effectiveSchemaContext = RFC7950Reactors.defaultReactor().newBuild()
  60                 .addSource(sourceForResource("/type-tests/types.yang"))
  61                 .buildEffective();
  62         types = effectiveSchemaContext.findModules("types").iterator().next();
  63         assertNotNull(types);
  64     }
  65
  66     @AfterClass
  67     public static void teardown() {
  68         effectiveSchemaContext = null;
  69         types = null;
  70     }
  71
  72     @Test
  73     public void testBinary() {
  74         currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-binary"));
  75         assertNotNull(currentLeaf.getType());
  76
  77         final BinaryTypeDefinition binaryEff = (BinaryTypeDefinition)
  78                 ((TypeEffectiveStatement<?>) ((LeafEffectiveStatement) currentLeaf)
  79                 .effectiveSubstatements().iterator().next()).getTypeDefinition();
  80
  81         assertNull(binaryEff.getBaseType());
  82         assertEquals(Optional.empty(), binaryEff.getUnits());
  83         assertEquals(Optional.empty(), binaryEff.getDefaultValue());
  84         assertEquals("binary", binaryEff.getQName().getLocalName());
  85         assertFalse(binaryEff.getLengthConstraint().isPresent());
  86         assertEquals(Status.CURRENT, binaryEff.getStatus());
  87         assertEquals("binary", binaryEff.getPath().getPathFromRoot().iterator().next().getLocalName());
  88         assertNotNull(binaryEff.getUnknownSchemaNodes());
  89         assertFalse(binaryEff.getDescription().isPresent());
  90         assertFalse(binaryEff.getReference().isPresent());
  91     }
  92
  93     @Test
  94     public void testBits() {
  95         currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-bits"));
  96         assertNotNull(currentLeaf.getType());
  97
  98         final Iterator<? extends Bit> bitsEffIter = ((BitsTypeDefinition) currentLeaf.getType()).getBits().iterator();
  99         final Bit bitEff = bitsEffIter.next();
 100         final Bit bitEffSecond = bitsEffIter.next();
 101
 102         final BitsTypeDefinition bitsEff = (BitsTypeDefinition) ((TypeDefinitionAware)
 103                 ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next())
 104                 .getTypeDefinition();
 105
 106         assertNull(bitsEff.getBaseType());
 107         assertNotNull(bitsEff.getQName());
 108         assertEquals("bits", bitsEff.getQName().getLocalName());
 109         assertEquals("bits", bitsEff.getPath().getLastComponent().getLocalName());
 110         assertNotNull(bitsEff.getUnknownSchemaNodes());
 111         assertFalse(bitsEff.getDescription().isPresent());
 112         assertFalse(bitsEff.getReference().isPresent());
 113         assertEquals(Status.CURRENT, bitsEff.getStatus());
 114         assertEquals(Optional.empty(), bitsEff.getUnits());
 115         assertNotNull(bitsEff.toString());
 116         assertNotNull(bitsEff.hashCode());
 117         assertFalse(bitsEff.equals(null));
 118         assertFalse(bitsEff.equals("test"));
 119         assertTrue(bitsEff.equals(bitsEff));
 120         assertEquals(3, bitsEff.getBits().size());
 121         assertEquals(Optional.empty(), bitsEff.getDefaultValue());
 122
 123         assertNotNull(bitEff.getUnknownSchemaNodes());
 124         assertEquals(Optional.of("test bit"), bitEff.getDescription());
 125         assertEquals(Optional.of("test bit ref"), bitEff.getReference());
 126         assertEquals(Status.CURRENT, bitEff.getStatus());
 127         assertNotNull(bitEff.hashCode());
 128         assertFalse(bitEff.equals(null));
 129         assertFalse(bitEff.equals("test"));
 130         assertFalse(bitEff.equals(bitEffSecond));
 131         assertNotNull(bitEff.toString());
 132         assertEquals("one", bitEff.getName());
 133         assertEquals(Uint32.ZERO, bitEff.getPosition());
 134     }
 135
 136     @Test
 137     public void testBoolean() {
 138         currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-boolean"));
 139         assertNotNull(currentLeaf.getType());
 140         final BooleanTypeDefinition booleanEff = (BooleanTypeDefinition) ((TypeEffectiveStatement<?>)
 141                 ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next())
 142                 .getTypeDefinition();
 143
 144         assertNull(booleanEff.getBaseType());
 145         assertEquals(Optional.empty(), booleanEff.getUnits());
 146         assertEquals(Optional.empty(), booleanEff.getDefaultValue());
 147         assertEquals("boolean", booleanEff.getQName().getLocalName());
 148         assertNull(booleanEff.getPath().getParent().getParent());
 149         assertNotNull(booleanEff.getUnknownSchemaNodes());
 150         assertFalse(booleanEff.getDescription().isPresent());
 151         assertFalse(booleanEff.getReference().isPresent());
 152         assertEquals(Status.CURRENT, booleanEff.getStatus());
 153         assertNotNull(booleanEff.toString());
 154     }
 155
 156     @Test
 157     public void testDecimal64() {
 158         currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-decimal64"));
 159         assertNotNull(currentLeaf.getType());
 160         final DecimalTypeDefinition decimal64Eff = (DecimalTypeDefinition) ((TypeDefinitionAware)
 161                 ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next())
 162                 .getTypeDefinition();
 163
 164         assertNull(decimal64Eff.getBaseType());
 165         assertEquals(Optional.empty(), decimal64Eff.getUnits());
 166         assertEquals(Optional.empty(), decimal64Eff.getDefaultValue());
 167         assertEquals("decimal64", decimal64Eff.getQName().getLocalName());
 168         assertNotNull(decimal64Eff.getUnknownSchemaNodes());
 169
 170         // FIXME: The yang model api is wrong: description/reference/status are not allowed under 'type', how come we
 171         // parse it?
 172         // allowed under 'type', how come we parse it?
 173         assertFalse(decimal64Eff.getDescription().isPresent());
 174         assertFalse(decimal64Eff.getReference().isPresent());
 175         assertEquals(Status.CURRENT, decimal64Eff.getStatus());
 176
 177         assertEquals(3, decimal64Eff.getRangeConstraint().get().getAllowedRanges().asRanges().size());
 178         assertNotNull(decimal64Eff.toString());
 179         assertNotNull(decimal64Eff.hashCode());
 180         assertEquals(2, decimal64Eff.getFractionDigits());
 181         assertFalse(decimal64Eff.equals(null));
 182         assertFalse(decimal64Eff.equals("test"));
 183         assertTrue(decimal64Eff.equals(decimal64Eff));
 184         assertEquals("decimal64", decimal64Eff.getPath().getLastComponent().getLocalName());
 185     }
 186
 187     @Test
 188     public void testEmpty() {
 189         currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-empty"));
 190         assertNotNull(currentLeaf.getType());
 191         final EmptyTypeDefinition emptyEff = (EmptyTypeDefinition) ((TypeEffectiveStatement<?>)
 192                 ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next())
 193                 .getTypeDefinition();
 194
 195         assertEquals(Optional.empty(), emptyEff.getUnits());
 196         assertEquals(Optional.empty(), emptyEff.getDefaultValue());
 197         assertNull(emptyEff.getBaseType());
 198         assertEquals("empty", emptyEff.getQName().getLocalName());
 199         assertNull(emptyEff.getPath().getParent().getParent());
 200         assertNotNull(emptyEff.getUnknownSchemaNodes());
 201         assertFalse(emptyEff.getDescription().isPresent());
 202         assertFalse(emptyEff.getReference().isPresent());
 203         assertEquals("CURRENT", emptyEff.getStatus().toString());
 204         assertNotNull(emptyEff.toString());
 205     }
 206
 207     @Test
 208     public void testEnum() {
 209         currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-enum"));
 210         assertNotNull(currentLeaf.getType());
 211         final List<EnumTypeDefinition.EnumPair> enumEffIter = ((EnumTypeDefinition) currentLeaf.getType()).getValues();
 212         final EnumPair enumEff = enumEffIter.iterator().next();
 213
 214         final EnumTypeDefinition enumSpecEff = (EnumTypeDefinition) ((TypeDefinitionAware)
 215                 ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next())
 216                 .getTypeDefinition();
 217
 218         assertEquals("enumeration", enumSpecEff.getQName().getLocalName());
 219         assertEquals("enumeration", enumSpecEff.getPath().getLastComponent().getLocalName());
 220         assertEquals(Optional.empty(), enumSpecEff.getDefaultValue());
 221         assertEquals(3, enumSpecEff.getValues().size());
 222         assertNull(enumSpecEff.getBaseType());
 223         assertNotNull(enumSpecEff.getUnknownSchemaNodes());
 224         assertEquals(Status.CURRENT, enumSpecEff.getStatus());
 225         assertFalse(enumSpecEff.getDescription().isPresent());
 226         assertFalse(enumSpecEff.getReference().isPresent());
 227         assertEquals(Optional.empty(), enumSpecEff.getUnits());
 228         assertNotNull(enumSpecEff.toString());
 229         assertNotNull(enumSpecEff.hashCode());
 230         assertFalse(enumSpecEff.equals(null));
 231         assertFalse(enumSpecEff.equals("test"));
 232         assertTrue(enumSpecEff.equals(enumSpecEff));
 233
 234         assertEquals("zero", enumEff.getName());
 235         assertNotNull(enumEff.getUnknownSchemaNodes());
 236         assertEquals(Optional.of("test enum"), enumEff.getDescription());
 237         assertEquals(Optional.of("test enum ref"), enumEff.getReference());
 238         assertEquals(Status.CURRENT, enumEff.getStatus());
 239         assertEquals(0, enumEff.getValue());
 240     }
 241
 242     @Test
 243     public void testIdentityRef() {
 244         currentLeaf = (LeafSchemaNode) types
 245                 .getDataChildByName(QName.create(types.getQNameModule(), "leaf-identityref"));
 246         assertNotNull(currentLeaf.getType());
 247         final IdentityrefTypeDefinition identityRefEff = (IdentityrefTypeDefinition) ((TypeDefinitionAware)
 248                 ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next())
 249                 .getTypeDefinition();
 250
 251         assertEquals(Optional.empty(), identityRefEff.getDefaultValue());
 252         assertEquals("identityref", identityRefEff.getQName().getLocalName());
 253         assertEquals("identityref", identityRefEff.getPath().getLastComponent().getLocalName());
 254         assertNull(identityRefEff.getBaseType());
 255         assertNotNull(identityRefEff.getUnknownSchemaNodes());
 256         assertEquals(Status.CURRENT, identityRefEff.getStatus());
 257         assertEquals("test-identity", identityRefEff.getIdentities().iterator().next().getQName().getLocalName());
 258         assertFalse(identityRefEff.getDescription().isPresent());
 259         assertFalse(identityRefEff.getReference().isPresent());
 260         assertNotNull(identityRefEff.toString());
 261
 262         // FIXME: the model is wrong, but we accept units in 'type' statement
 263         assertEquals(Optional.empty(), identityRefEff.getUnits());
 264     }
 265
 266     @Test
 267     public void testInstanceIdentifier() {
 268         currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(),
 269                 "leaf-instance-identifier"));
 270         assertNotNull(currentLeaf.getType());
 271         final InstanceIdentifierTypeDefinition instanceIdentEff = (InstanceIdentifierTypeDefinition)
 272                 ((TypeEffectiveStatement<?>) ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements()
 273                         .iterator().next()).getTypeDefinition();
 274         assertNotNull(instanceIdentEff.toString());
 275
 276         assertFalse(instanceIdentEff.requireInstance());
 277         assertEquals("instance-identifier", instanceIdentEff.getQName().getLocalName());
 278         assertEquals("instance-identifier", instanceIdentEff.getPath().getLastComponent().getLocalName());
 279         assertNull(instanceIdentEff.getBaseType());
 280         assertEquals(Optional.empty(), instanceIdentEff.getDefaultValue());
 281         assertNotNull(instanceIdentEff.getUnknownSchemaNodes());
 282         assertFalse(instanceIdentEff.getDescription().isPresent());
 283         assertFalse(instanceIdentEff.getReference().isPresent());
 284         assertEquals(Optional.empty(), instanceIdentEff.getUnits());
 285         assertEquals(Status.CURRENT, instanceIdentEff.getStatus());
 286         assertNotNull(instanceIdentEff.hashCode());
 287         assertFalse(instanceIdentEff.equals(null));
 288         assertFalse(instanceIdentEff.equals("test"));
 289         assertTrue(instanceIdentEff.equals(instanceIdentEff));
 290     }
 291
 292     @Test
 293     public void testLeafref() {
 294         currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-leafref"));
 295         assertNotNull(currentLeaf.getType());
 296
 297         final LeafrefTypeDefinition leafrefEff = (LeafrefTypeDefinition) ((TypeDefinitionAware)
 298                 ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next())
 299                 .getTypeDefinition();
 300
 301         assertEquals("/container-test/leaf-test", leafrefEff.getPathStatement().getOriginalString());
 302         assertNull(leafrefEff.getBaseType());
 303         assertEquals(Optional.empty(), leafrefEff.getUnits());
 304         assertEquals(Optional.empty(), leafrefEff.getDefaultValue());
 305         assertNotNull(leafrefEff.toString());
 306         assertEquals("leafref", leafrefEff.getQName().getLocalName());
 307         assertEquals(Status.CURRENT, leafrefEff.getStatus());
 308         assertNotNull(leafrefEff.getUnknownSchemaNodes());
 309         assertEquals("leafref", leafrefEff.getPath().getLastComponent().getLocalName());
 310         assertFalse(leafrefEff.getDescription().isPresent());
 311         assertFalse(leafrefEff.getReference().isPresent());
 312         assertNotNull(leafrefEff.hashCode());
 313         assertFalse(leafrefEff.equals(null));
 314         assertFalse(leafrefEff.equals("test"));
 315         assertTrue(leafrefEff.equals(leafrefEff));
 316     }
 317
 318     @Test
 319     public void testLeafrefWithDeref() {
 320         currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName
 321                 .create(types.getQNameModule(), "leaf-leafref-deref"));
 322         assertNotNull(currentLeaf.getType());
 323
 324         final LeafrefTypeDefinition leafrefEff = (LeafrefTypeDefinition) ((TypeDefinitionAware)
 325                 ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next())
 326                 .getTypeDefinition();
 327
 328         assertEquals("deref(../container-test)/leaf-test",
 329                 leafrefEff.getPathStatement().getOriginalString());
 330         assertNull(leafrefEff.getBaseType());
 331         assertEquals(Optional.empty(), leafrefEff.getUnits());
 332         assertEquals(Optional.empty(), leafrefEff.getDefaultValue());
 333         assertNotNull(leafrefEff.toString());
 334         assertEquals("leafref", leafrefEff.getQName().getLocalName());
 335         assertEquals(Status.CURRENT, leafrefEff.getStatus());
 336         assertNotNull(leafrefEff.getUnknownSchemaNodes());
 337         assertEquals("leafref", leafrefEff.getPath().getLastComponent().getLocalName());
 338         assertFalse(leafrefEff.getDescription().isPresent());
 339         assertFalse(leafrefEff.getReference().isPresent());
 340         assertNotNull(leafrefEff.hashCode());
 341         assertFalse(leafrefEff.equals(null));
 342         assertFalse(leafrefEff.equals("test"));
 343         assertTrue(leafrefEff.equals(leafrefEff));
 344     }
 345
 346     @Test
 347     public void testIntAll() {
 348         currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-int8"));
 349         assertNotNull(currentLeaf.getType());
 350         final TypeEffectiveStatement<?> int8Eff = (TypeEffectiveStatement<?>)
 351                 ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next();
 352         assertNotNull(int8Eff.toString());
 353
 354         currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-int16"));
 355         assertNotNull(currentLeaf.getType());
 356         final TypeEffectiveStatement<?> int16Eff = (TypeEffectiveStatement<?>)
 357                 ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next();
 358         assertNotNull(int16Eff.toString());
 359
 360         currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-int32"));
 361         assertNotNull(currentLeaf.getType());
 362         final TypeEffectiveStatement<?> int32Eff = (TypeEffectiveStatement<?>)
 363                 ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next();
 364         assertNotNull(int32Eff.toString());
 365
 366         currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-int64"));
 367         assertNotNull(currentLeaf.getType());
 368         final TypeEffectiveStatement<?> int64Eff = (TypeEffectiveStatement<?>)
 369                 ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next();
 370         assertNotNull(int64Eff.toString());
 371
 372         currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-uint8"));
 373         assertNotNull(currentLeaf.getType());
 374         final TypeEffectiveStatement<?> uint8Eff = (TypeEffectiveStatement<?>)
 375                 ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next();
 376         assertNotNull(uint8Eff.toString());
 377
 378         currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-uint16"));
 379         assertNotNull(currentLeaf.getType());
 380         final TypeEffectiveStatement<?> uint16Eff = (TypeEffectiveStatement<?>)
 381                 ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next();
 382         assertNotNull(uint16Eff.toString());
 383
 384         currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-uint32"));
 385         assertNotNull(currentLeaf.getType());
 386         final TypeEffectiveStatement<?> uint32Eff = (TypeEffectiveStatement<?>)
 387                 ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next();
 388         assertNotNull(uint32Eff.toString());
 389
 390         currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-uint64"));
 391         assertNotNull(currentLeaf.getType());
 392         final TypeEffectiveStatement<?> uint64Eff = (TypeEffectiveStatement<?>)
 393                 ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next();
 394         assertNotNull(uint64Eff.toString());
 395     }
 396
 397     @Test
 398     public void testUnion() {
 399         currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-union"));
 400         assertNotNull(currentLeaf.getType());
 401         final UnionTypeDefinition unionEff = (UnionTypeDefinition) ((TypeDefinitionAware)
 402                 ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next())
 403                 .getTypeDefinition();
 404
 405         assertEquals(2, unionEff.getTypes().size());
 406         assertEquals("union", unionEff.getQName().getLocalName());
 407         assertEquals("CURRENT", unionEff.getStatus().toString());
 408         assertNotNull(unionEff.getUnknownSchemaNodes());
 409         assertNull(unionEff.getBaseType());
 410         assertEquals(Optional.empty(), unionEff.getUnits());
 411         assertEquals(Optional.empty(), unionEff.getDefaultValue());
 412         assertFalse(unionEff.getDescription().isPresent());
 413         assertFalse(unionEff.getReference().isPresent());
 414         assertNotNull(unionEff.toString());
 415         assertNotNull(unionEff.hashCode());
 416         assertFalse(unionEff.equals(null));
 417         assertFalse(unionEff.equals("test"));
 418         assertTrue(unionEff.equals(unionEff));
 419         assertEquals("union", unionEff.getPath().getLastComponent().getLocalName());
 420     }
 421
 422     @Test
 423     public void testLengthConstraint() {
 424         currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(),
 425                 "leaf-length-pattern"));
 426
 427         final StringTypeDefinition leafType = (StringTypeDefinition) currentLeaf.getType();
 428         assertNotNull(leafType);
 429         final LengthConstraint lengthConstraint = leafType.getLengthConstraint().get();
 430
 431         final Range<Integer> span = lengthConstraint.getAllowedRanges().span();
 432         assertEquals(1, span.lowerEndpoint().intValue());
 433         assertEquals(255, span.upperEndpoint().intValue());
 434         assertFalse(lengthConstraint.getReference().isPresent());
 435         assertFalse(lengthConstraint.getDescription().isPresent());
 436         assertFalse(lengthConstraint.getErrorMessage().isPresent());
 437         assertFalse(lengthConstraint.getErrorAppTag().isPresent());
 438         assertNotNull(lengthConstraint.toString());
 439         assertNotNull(lengthConstraint.hashCode());
 440         assertFalse(lengthConstraint.equals(null));
 441         assertFalse(lengthConstraint.equals("test"));
 442
 443         currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(),
 444                 "leaf-length-pattern-second"));
 445         assertNotNull(currentLeaf.getType());
 446         final LengthConstraint lengthConstraintSecond = ((StringTypeDefinition) currentLeaf.getType())
 447                 .getLengthConstraint().get();
 448         assertFalse(lengthConstraint.equals(lengthConstraintSecond));
 449     }
 450
 451     @Test
 452     public void testPatternConstraint() {
 453         currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(),
 454                 "leaf-length-pattern"));
 455         assertNotNull(currentLeaf.getType());
 456         final PatternConstraint patternConstraint = ((StringTypeDefinition) currentLeaf.getType())
 457                 .getPatternConstraints().get(0);
 458         final PatternConstraint patternConstraintThird = ((StringTypeDefinition) currentLeaf.getType())
 459                 .getPatternConstraints().get(0);
 460         currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(),
 461                 "leaf-length-pattern-second"));
 462         assertNotNull(currentLeaf.getType());
 463         final PatternConstraint patternConstraintSecond = ((StringTypeDefinition) currentLeaf.getType())
 464                 .getPatternConstraints().get(0);
 465
 466         assertEquals("^(?:[0-9a-fA-F]*)$", patternConstraint.getJavaPatternString());
 467         assertFalse(patternConstraint.getReference().isPresent());
 468         assertFalse(patternConstraint.getDescription().isPresent());
 469         assertEquals(Optional.empty(), patternConstraint.getErrorMessage());
 470         assertEquals(Optional.empty(), patternConstraint.getErrorAppTag());
 471         assertNotNull(patternConstraint.toString());
 472         assertNotNull(patternConstraint.hashCode());
 473         assertFalse(patternConstraint.equals(null));
 474         assertFalse(patternConstraint.equals("test"));
 475         assertFalse(patternConstraint.equals(patternConstraintSecond));
 476         assertTrue(patternConstraint.equals(patternConstraintThird));
 477     }
 478
 479     @Test
 480     public void testString() {
 481         currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-string"));
 482         assertNotNull(currentLeaf.getType());
 483         final StringTypeDefinition stringEff = (StringTypeDefinition) ((TypeEffectiveStatement<?>)
 484                 ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next())
 485                 .getTypeDefinition();
 486
 487         assertEquals("string", stringEff.getQName().getLocalName());
 488         assertEquals(Status.CURRENT, stringEff.getStatus());
 489         assertEquals(Optional.empty(), stringEff.getUnits());
 490         assertEquals(Optional.empty(), stringEff.getDefaultValue());
 491         assertNotNull(stringEff.getUnknownSchemaNodes());
 492         assertNull(stringEff.getBaseType());
 493         assertFalse(stringEff.getDescription().isPresent());
 494         assertFalse(stringEff.getReference().isPresent());
 495         assertNotNull(stringEff.toString());
 496         assertNotNull(stringEff.hashCode());
 497         assertFalse(stringEff.equals(null));
 498         assertFalse(stringEff.equals("test"));
 499         assertTrue(stringEff.equals(stringEff));
 500         assertEquals("string", stringEff.getPath().getLastComponent().getLocalName());
 501         assertFalse(stringEff.getLengthConstraint().isPresent());
 502         assertNotNull(stringEff.getPatternConstraints());
 503     }
 504 }