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