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