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