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