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