yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/type/TypeTest.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.model.util.type;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertFalse;
  12 import static org.junit.Assert.assertNotNull;
  13 import static org.junit.Assert.assertSame;
  14 import static org.junit.Assert.assertThrows;
  15 import static org.junit.Assert.assertTrue;
  16 import static org.mockito.Mockito.doReturn;
  17 import static org.mockito.Mockito.mock;
  18
  19 import com.google.common.collect.ImmutableList;
  20 import com.google.common.collect.ImmutableRangeSet;
  21 import com.google.common.collect.Range;
  22 import com.google.common.collect.RangeSet;
  23 import java.util.List;
  24 import java.util.Optional;
  25 import org.junit.Test;
  26 import org.opendaylight.yangtools.concepts.Builder;
  27 import org.opendaylight.yangtools.yang.common.QName;
  28 import org.opendaylight.yangtools.yang.common.Uint32;
  29 import org.opendaylight.yangtools.yang.model.api.ConstraintMetaDefinition;
  30 import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
  31 import org.opendaylight.yangtools.yang.model.api.PathExpression;
  32 import org.opendaylight.yangtools.yang.model.api.Status;
  33 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
  34 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
  35 import org.opendaylight.yangtools.yang.model.api.stmt.UnresolvedNumber;
  36 import org.opendaylight.yangtools.yang.model.api.stmt.ValueRange;
  37 import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
  38 import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
  39 import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition.Bit;
  40 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair;
  41 import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
  42 import org.opendaylight.yangtools.yang.model.api.type.InstanceIdentifierTypeDefinition;
  43 import org.opendaylight.yangtools.yang.model.api.type.Int16TypeDefinition;
  44 import org.opendaylight.yangtools.yang.model.api.type.Int32TypeDefinition;
  45 import org.opendaylight.yangtools.yang.model.api.type.Int64TypeDefinition;
  46 import org.opendaylight.yangtools.yang.model.api.type.Int8TypeDefinition;
  47 import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
  48 import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
  49 import org.opendaylight.yangtools.yang.model.api.type.Uint16TypeDefinition;
  50 import org.opendaylight.yangtools.yang.model.api.type.Uint32TypeDefinition;
  51 import org.opendaylight.yangtools.yang.model.api.type.Uint64TypeDefinition;
  52 import org.opendaylight.yangtools.yang.model.api.type.Uint8TypeDefinition;
  53 import org.opendaylight.yangtools.yang.model.util.BaseConstraints;
  54 import org.opendaylight.yangtools.yang.model.util.PathExpressionImpl;
  55
  56 public class TypeTest {
  57     private static final QName Q_NAME = QName.create("test.namespace", "2016-01-01", "test-name");
  58     private static final PathExpression REVISION_AWARE_XPATH = new PathExpressionImpl("/test", true);
  59     private static final Bit BIT_A = BitBuilder.create(Q_NAME.getLocalName(), Uint32.valueOf(55L))
  60         .setDescription("description")
  61         .setReference("reference")
  62         .build();
  63     private static final Optional<String> ABSENT = Optional.empty();
  64
  65     @Test
  66     public void binaryTypeTest() {
  67         final BaseBinaryType baseBinaryType1 = BaseBinaryType.INSTANCE;
  68         final BaseBinaryType baseBinaryType2 = (BaseBinaryType)BaseTypes.binaryType();
  69         hashCodeEqualsToStringTest(baseBinaryType1, baseBinaryType2);
  70         assertEquals(baseBinaryType1.getLengthConstraint(), baseBinaryType2.getLengthConstraint());
  71
  72         final DerivedBinaryType derivedBinaryType1 = (DerivedBinaryType)DerivedTypes.derivedTypeBuilder(baseBinaryType1,
  73             Q_NAME).build();
  74         final DerivedBinaryType derivedBinaryType2 = (DerivedBinaryType)DerivedTypes.derivedTypeBuilder(baseBinaryType2,
  75             Q_NAME).build();
  76         hashCodeEqualsToStringTest(derivedBinaryType1, derivedBinaryType2);
  77
  78         final RestrictedBinaryType restrictedBinaryType1 = (RestrictedBinaryType)RestrictedTypes.newBinaryBuilder(
  79                 baseBinaryType1, Q_NAME).buildType();
  80         final RestrictedBinaryType restrictedBinaryType2 = (RestrictedBinaryType)RestrictedTypes.newBinaryBuilder(
  81                 baseBinaryType2, Q_NAME).buildType();
  82         hashCodeEqualsToStringTest(restrictedBinaryType1, restrictedBinaryType2);
  83
  84         final LengthRestrictedTypeBuilder<BinaryTypeDefinition> lengthRestrictedTypeBuilder = RestrictedTypes
  85                 .newBinaryBuilder(baseBinaryType1, Q_NAME);
  86         final BaseBinaryType baseBinaryType = (BaseBinaryType)lengthRestrictedTypeBuilder.build();
  87         assertEquals(baseBinaryType, baseBinaryType1);
  88         concreteBuilderTest(baseBinaryType1, derivedBinaryType1);
  89     }
  90
  91     @Test
  92     public void booleanTypeTest() {
  93         final BaseBooleanType baseBooleanType1 = BaseBooleanType.INSTANCE;
  94         final BaseBooleanType baseBooleanType2 = (BaseBooleanType)BaseTypes.booleanType();
  95         hashCodeEqualsToStringTest(baseBooleanType1, baseBooleanType2);
  96
  97         final DerivedBooleanType derivedBooleanType1 = (DerivedBooleanType)DerivedTypes.derivedTypeBuilder(
  98                 baseBooleanType1, Q_NAME).build();
  99         final DerivedBooleanType derivedBooleanType2 = (DerivedBooleanType)DerivedTypes.derivedTypeBuilder(
 100                 baseBooleanType1, Q_NAME).build();
 101         hashCodeEqualsToStringTest(derivedBooleanType1, derivedBooleanType2);
 102
 103         restrictedBuilderTest(RestrictedTypes.newBooleanBuilder(baseBooleanType1, Q_NAME), RestrictedTypes
 104                 .newBooleanBuilder(baseBooleanType2, Q_NAME));
 105         concreteBuilderTest(baseBooleanType1, derivedBooleanType1);
 106     }
 107
 108     @Test
 109     public void identityrefTypeTest() {
 110         final IdentityrefTypeBuilder identityrefTypeBuilder1 = BaseTypes.identityrefTypeBuilder(Q_NAME);
 111         final IdentitySchemaNode identitySchemaNode = mock(IdentitySchemaNode.class);
 112         doReturn("identitySchemaNode").when(identitySchemaNode).toString();
 113         identityrefTypeBuilder1.addIdentity(identitySchemaNode);
 114         final IdentityrefTypeDefinition identityrefTypeDefinition1 = identityrefTypeBuilder1.build();
 115         final IdentityrefTypeBuilder identityrefTypeBuilder2 = BaseTypes.identityrefTypeBuilder(Q_NAME);
 116         identityrefTypeBuilder2.addIdentity(identitySchemaNode);
 117         final IdentityrefTypeDefinition identityrefTypeDefinition2 = identityrefTypeBuilder2.build();
 118         hashCodeEqualsToStringTest(identityrefTypeDefinition1, identityrefTypeDefinition2);
 119
 120         final DerivedIdentityrefType derivedIdentityrefType1 = (DerivedIdentityrefType)DerivedTypes.derivedTypeBuilder(
 121                 identityrefTypeDefinition1, Q_NAME).build();
 122         final DerivedIdentityrefType derivedIdentityrefType2 = (DerivedIdentityrefType)DerivedTypes.derivedTypeBuilder(
 123                 identityrefTypeDefinition2, Q_NAME).build();
 124         hashCodeEqualsToStringTest(derivedIdentityrefType1, derivedIdentityrefType2);
 125         concreteBuilderTest(identityrefTypeDefinition1, derivedIdentityrefType1);
 126
 127         restrictedBuilderTest(RestrictedTypes.newIdentityrefBuilder(derivedIdentityrefType1, Q_NAME),
 128                 RestrictedTypes.newIdentityrefBuilder(derivedIdentityrefType2, Q_NAME));
 129     }
 130
 131     @Test
 132     public void decimalTypeTest() {
 133         final BaseDecimalType baseDecimalType1 = (BaseDecimalType)BaseTypes.decimalTypeBuilder(Q_NAME)
 134                 .setFractionDigits(1)
 135                 .buildType();
 136         final BaseDecimalType baseDecimalType2 = (BaseDecimalType)BaseTypes.decimalTypeBuilder(Q_NAME)
 137                 .setFractionDigits(1)
 138                 .buildType();
 139         hashCodeEqualsToStringTest(baseDecimalType1, baseDecimalType2);
 140         assertEquals(baseDecimalType1.getFractionDigits(), baseDecimalType2.getFractionDigits());
 141
 142         final DerivedDecimalType derivedDecimalType1 = (DerivedDecimalType)DerivedTypes
 143                 .derivedTypeBuilder(baseDecimalType1, Q_NAME).build();
 144         final DerivedDecimalType derivedDecimalType2 = (DerivedDecimalType)DerivedTypes
 145                 .derivedTypeBuilder(baseDecimalType1, Q_NAME).build();
 146         hashCodeEqualsToStringTest(derivedDecimalType1, derivedDecimalType2);
 147
 148         final RestrictedDecimalType restrictedDecimalType1 = (RestrictedDecimalType)
 149                 RestrictedTypes.newDecima64Builder(baseDecimalType1, Q_NAME).buildType();
 150         final RestrictedDecimalType restrictedDecimalType2 = (RestrictedDecimalType)
 151                 RestrictedTypes.newDecima64Builder(baseDecimalType2, Q_NAME).buildType();
 152         hashCodeEqualsToStringTest(restrictedDecimalType1, restrictedDecimalType2);
 153         concreteBuilderTest(baseDecimalType1, derivedDecimalType1);
 154     }
 155
 156     @Test
 157     public void emptyTypeTest() {
 158         final BaseEmptyType baseEmptyType1 = BaseEmptyType.INSTANCE;
 159         final BaseEmptyType baseEmptyType2 = (BaseEmptyType)BaseTypes.emptyType();
 160         hashCodeEqualsToStringTest(baseEmptyType1, baseEmptyType2);
 161
 162         final DerivedEmptyType derivedEmptyType1 = (DerivedEmptyType)DerivedTypes.derivedTypeBuilder(
 163                 baseEmptyType1, Q_NAME).build();
 164         final DerivedEmptyType derivedEmptyType2 = (DerivedEmptyType)DerivedTypes.derivedTypeBuilder(
 165                 baseEmptyType2, Q_NAME).build();
 166         hashCodeEqualsToStringTest(derivedEmptyType1, derivedEmptyType2);
 167
 168         restrictedBuilderTest(RestrictedTypes.newEmptyBuilder(baseEmptyType1, Q_NAME),
 169                 RestrictedTypes.newEmptyBuilder(baseEmptyType2, Q_NAME));
 170         concreteBuilderTest(baseEmptyType1, derivedEmptyType1);
 171     }
 172
 173     @Test
 174     public void instanceIdentifierTypeTest() {
 175         final BaseInstanceIdentifierType baseInstanceIdentifierType1 = BaseInstanceIdentifierType.INSTANCE;
 176         final BaseInstanceIdentifierType baseInstanceIdentifierType2 = (BaseInstanceIdentifierType)BaseTypes
 177                 .instanceIdentifierType();
 178         hashCodeEqualsToStringTest(baseInstanceIdentifierType1, baseInstanceIdentifierType2);
 179         assertFalse(baseInstanceIdentifierType1.requireInstance());
 180
 181         final DerivedInstanceIdentifierType derivedInstanceIdentifierType1 = (DerivedInstanceIdentifierType)
 182                 DerivedTypes.derivedTypeBuilder(baseInstanceIdentifierType1, Q_NAME).build();
 183         final DerivedInstanceIdentifierType derivedInstanceIdentifierType2 = (DerivedInstanceIdentifierType)
 184                 DerivedTypes.derivedTypeBuilder(baseInstanceIdentifierType2, Q_NAME).build();
 185         hashCodeEqualsToStringTest(derivedInstanceIdentifierType1, derivedInstanceIdentifierType2);
 186
 187         final InstanceIdentifierTypeBuilder instanceIdentifierBuilder1 = RestrictedTypes
 188                 .newInstanceIdentifierBuilder(baseInstanceIdentifierType1, Q_NAME);
 189         instanceIdentifierBuilder1.setRequireInstance(true);
 190         final InstanceIdentifierTypeDefinition instanceIdentifierTypeDefinition1 = instanceIdentifierBuilder1
 191                 .buildType();
 192         final InstanceIdentifierTypeBuilder instanceIdentifierBuilder2 = RestrictedTypes
 193                 .newInstanceIdentifierBuilder(baseInstanceIdentifierType1, Q_NAME);
 194         instanceIdentifierBuilder2.setRequireInstance(true);
 195         final InstanceIdentifierTypeDefinition instanceIdentifierTypeDefinition2 = instanceIdentifierBuilder2
 196                 .buildType();
 197         hashCodeEqualsToStringTest(instanceIdentifierTypeDefinition2, instanceIdentifierTypeDefinition1);
 198         concreteBuilderTest(baseInstanceIdentifierType1, derivedInstanceIdentifierType1);
 199     }
 200
 201     @Test
 202     public void integerTypeTest() {
 203         final Int8TypeDefinition integerTypeDefinition8 = BaseTypes.int8Type();
 204         final Int16TypeDefinition integerTypeDefinition16 = BaseTypes.int16Type();
 205         final Int32TypeDefinition integerTypeDefinition32 = BaseTypes.int32Type();
 206         final Int64TypeDefinition integerTypeDefinition64 = BaseTypes.int64Type();
 207         testInstance(BaseInt8Type.INSTANCE, integerTypeDefinition8);
 208         testInstance(BaseInt16Type.INSTANCE, integerTypeDefinition16);
 209         testInstance(BaseInt32Type.INSTANCE, integerTypeDefinition32);
 210         testInstance(BaseInt64Type.INSTANCE, integerTypeDefinition64);
 211
 212         final RestrictedInt8Type restrictedIntegerType1 = (RestrictedInt8Type)RestrictedTypes.newInt8Builder(
 213                 integerTypeDefinition8, Q_NAME).buildType();
 214         final RestrictedInt8Type restrictedIntegerType2 = (RestrictedInt8Type)RestrictedTypes.newInt8Builder(
 215                 BaseInt8Type.INSTANCE, Q_NAME).buildType();
 216         hashCodeEqualsToStringTest(restrictedIntegerType1, restrictedIntegerType2);
 217
 218         final Uint8TypeDefinition integerTypeDefinitionu8 = BaseTypes.uint8Type();
 219         final Uint16TypeDefinition integerTypeDefinitionu16 = BaseTypes.uint16Type();
 220         final Uint32TypeDefinition integerTypeDefinitionu32 = BaseTypes.uint32Type();
 221         final Uint64TypeDefinition integerTypeDefinitionu64 = BaseTypes.uint64Type();
 222         testInstance(BaseUint8Type.INSTANCE, integerTypeDefinitionu8);
 223         testInstance(BaseUint16Type.INSTANCE, integerTypeDefinitionu16);
 224         testInstance(BaseUint32Type.INSTANCE, integerTypeDefinitionu32);
 225         testInstance(BaseUint64Type.INSTANCE, BaseTypes.baseTypeOf(integerTypeDefinitionu64));
 226
 227         final DerivedInt8Type derivedIntegerType1 = (DerivedInt8Type)DerivedTypes
 228                 .derivedTypeBuilder(integerTypeDefinition8, Q_NAME).build();
 229         final DerivedInt8Type derivedIntegerType2 = (DerivedInt8Type)DerivedTypes
 230                 .derivedTypeBuilder(BaseInt8Type.INSTANCE, Q_NAME).build();
 231         hashCodeEqualsToStringTest(derivedIntegerType1, derivedIntegerType2);
 232
 233         final DerivedUint8Type derivedUnsignedType1 = (DerivedUint8Type)DerivedTypes
 234                 .derivedTypeBuilder(integerTypeDefinitionu8, Q_NAME).build();
 235         final DerivedUint8Type derivedUnsignedType2 = (DerivedUint8Type)DerivedTypes
 236                 .derivedTypeBuilder(BaseUint8Type.INSTANCE, Q_NAME).build();
 237         hashCodeEqualsToStringTest(derivedUnsignedType1, derivedUnsignedType2);
 238
 239         final RestrictedUint8Type restrictedUnsignedType1 = (RestrictedUint8Type)RestrictedTypes
 240                 .newUint8Builder(integerTypeDefinitionu8, Q_NAME).buildType();
 241         final RestrictedUint8Type restrictedUnsignedType2 = (RestrictedUint8Type)RestrictedTypes
 242                 .newUint8Builder(BaseUint8Type.INSTANCE, Q_NAME).buildType();
 243         hashCodeEqualsToStringTest(restrictedUnsignedType1, restrictedUnsignedType2);
 244         concreteBuilderTest(integerTypeDefinition8, derivedIntegerType1);
 245         concreteBuilderTest(integerTypeDefinitionu8, derivedUnsignedType2);
 246
 247         final DerivedTypeBuilder<?> derivedTypeBuilder = DerivedTypes.derivedTypeBuilder(integerTypeDefinition8,
 248             Q_NAME);
 249         derivedTypeBuilder.setDefaultValue(1);
 250         derivedTypeBuilder.setDescription("test-description");
 251         derivedTypeBuilder.setReference("test-reference");
 252         derivedTypeBuilder.setUnits("Int");
 253         derivedTypeBuilder.setStatus(Status.CURRENT);
 254         assertEquals(derivedTypeBuilder.getStatus(), Status.CURRENT);
 255         assertEquals(derivedTypeBuilder.getDescription(), "test-description");
 256         assertEquals(derivedTypeBuilder.getReference(), "test-reference");
 257         assertEquals(derivedTypeBuilder.getUnits(), "Int");
 258     }
 259
 260     @Test
 261     public void stringTypeTest() {
 262         final BaseStringType baseStringType1 = BaseStringType.INSTANCE;
 263         final BaseStringType baseStringType2 = (BaseStringType)BaseTypes.stringType();
 264         hashCodeEqualsToStringTest(baseStringType1, baseStringType2);
 265         assertEquals(baseStringType1.getLengthConstraint(), baseStringType2.getLengthConstraint());
 266         assertEquals(baseStringType1.getPatternConstraints(), baseStringType2.getPatternConstraints());
 267
 268         final DerivedStringType derivedStringType1 = (DerivedStringType)
 269                 DerivedTypes.derivedTypeBuilder(baseStringType1, Q_NAME).build();
 270         final DerivedStringType derivedStringType2 = (DerivedStringType)
 271                 DerivedTypes.derivedTypeBuilder(baseStringType2, Q_NAME).build();
 272         hashCodeEqualsToStringTest(derivedStringType1, derivedStringType2);
 273
 274         final RestrictedStringType restrictedStringType1 = (RestrictedStringType)RestrictedTypes
 275                 .newStringBuilder(baseStringType1, Q_NAME).buildType();
 276         final RestrictedStringType restrictedStringType2 = (RestrictedStringType)RestrictedTypes
 277                 .newStringBuilder(baseStringType2, Q_NAME).buildType();
 278         hashCodeEqualsToStringTest(restrictedStringType1, restrictedStringType2);
 279         concreteBuilderTest(baseStringType1, derivedStringType1);
 280
 281         final StringTypeBuilder stringTypeBuilder = new StringTypeBuilder(baseStringType1, Q_NAME);
 282         final PatternConstraint patternConstraint = BaseConstraints.newPatternConstraint("pattern", ABSENT, ABSENT);
 283         stringTypeBuilder.addPatternConstraint(patternConstraint);
 284         final StringTypeDefinition stringTypeDefinition = stringTypeBuilder.buildType();
 285         assertNotNull(stringTypeDefinition);
 286     }
 287
 288     @Test
 289     public void bitsTypeTest() {
 290         final BitsTypeBuilder bitsTypeBuilder = BaseTypes.bitsTypeBuilder(Q_NAME);
 291         bitsTypeBuilder.addBit(BIT_A);
 292         final BitsTypeDefinition bitsTypeDefinition1 = bitsTypeBuilder.build();
 293         final BitsTypeDefinition bitsTypeDefinition2 = bitsTypeBuilder.build();
 294         hashCodeEqualsToStringTest(bitsTypeDefinition1, bitsTypeDefinition2);
 295         assertEquals(bitsTypeDefinition1.getBits(), bitsTypeDefinition1.getBits());
 296
 297         final DerivedBitsType derivedBitsType1 = (DerivedBitsType)DerivedTypes
 298                 .derivedTypeBuilder(bitsTypeDefinition1, Q_NAME).build();
 299         final DerivedBitsType derivedBitsType2 = (DerivedBitsType)DerivedTypes
 300                 .derivedTypeBuilder(bitsTypeDefinition2, Q_NAME).build();
 301         hashCodeEqualsToStringTest(derivedBitsType1, derivedBitsType2);
 302
 303         restrictedBuilderTest(RestrictedTypes.newBitsBuilder(bitsTypeDefinition1, Q_NAME),
 304                 RestrictedTypes.newBitsBuilder(bitsTypeDefinition2, Q_NAME));
 305         concreteBuilderTest(bitsTypeDefinition1, derivedBitsType1);
 306     }
 307
 308     @Test
 309     public void enumerationTypeTest() {
 310         final BaseEnumerationType baseEnumerationType1 = (BaseEnumerationType)BaseTypes.enumerationTypeBuilder(Q_NAME)
 311             .build();
 312         final BaseEnumerationType baseEnumerationType2 = (BaseEnumerationType)BaseTypes.enumerationTypeBuilder(Q_NAME)
 313             .build();
 314         hashCodeEqualsToStringTest(baseEnumerationType1, baseEnumerationType2);
 315         assertEquals(baseEnumerationType1.getValues(), baseEnumerationType2.getValues());
 316
 317         final DerivedEnumerationType derivedEnumerationType1 = (DerivedEnumerationType)DerivedTypes
 318                 .derivedTypeBuilder(baseEnumerationType1, Q_NAME).build();
 319         final DerivedEnumerationType derivedEnumerationType2 = (DerivedEnumerationType)DerivedTypes
 320                 .derivedTypeBuilder(baseEnumerationType2, Q_NAME).build();
 321         hashCodeEqualsToStringTest(derivedEnumerationType1, derivedEnumerationType2);
 322
 323         restrictedBuilderTest(RestrictedTypes.newEnumerationBuilder(baseEnumerationType1, Q_NAME),
 324                 RestrictedTypes.newEnumerationBuilder(baseEnumerationType2, Q_NAME));
 325         concreteBuilderTest(baseEnumerationType1, derivedEnumerationType1);
 326     }
 327
 328     @Test
 329     public void leafrefTypeTest() {
 330         final LeafrefTypeBuilder leafrefTypeBuilder1 = BaseTypes.leafrefTypeBuilder(Q_NAME);
 331         final LeafrefTypeBuilder leafrefTypeBuilder2 = BaseTypes.leafrefTypeBuilder(Q_NAME);
 332         leafrefTypeBuilder1.setPathStatement(REVISION_AWARE_XPATH);
 333         leafrefTypeBuilder2.setPathStatement(REVISION_AWARE_XPATH);
 334         final BaseLeafrefType baseLeafrefType1 = (BaseLeafrefType)leafrefTypeBuilder1.build();
 335         final BaseLeafrefType baseLeafrefType2 = (BaseLeafrefType)leafrefTypeBuilder1.build();
 336         hashCodeEqualsToStringTest(baseLeafrefType1, baseLeafrefType2);
 337         assertEquals(baseLeafrefType1.getPathStatement(), REVISION_AWARE_XPATH);
 338
 339         final DerivedLeafrefType derivedLeafrefType1 = (DerivedLeafrefType)DerivedTypes
 340                 .derivedTypeBuilder(baseLeafrefType1, Q_NAME).build();
 341         final DerivedLeafrefType derivedLeafrefType2 = (DerivedLeafrefType)DerivedTypes
 342                 .derivedTypeBuilder(baseLeafrefType2, Q_NAME).build();
 343         hashCodeEqualsToStringTest(derivedLeafrefType1, derivedLeafrefType2);
 344
 345         restrictedBuilderTest(RestrictedTypes.newLeafrefBuilder(baseLeafrefType1, Q_NAME),
 346                 RestrictedTypes.newLeafrefBuilder(baseLeafrefType2, Q_NAME));
 347         concreteBuilderTest(baseLeafrefType1, derivedLeafrefType1);
 348     }
 349
 350     @Test
 351     public void unionTypeTest() throws IllegalAccessException, InstantiationException {
 352         final BaseDecimalType baseDecimalType1 = (BaseDecimalType)BaseTypes.decimalTypeBuilder(Q_NAME)
 353                 .setFractionDigits(1)
 354                 .buildType();
 355         final BaseDecimalType baseDecimalType2 = (BaseDecimalType)BaseTypes.decimalTypeBuilder(Q_NAME)
 356                 .setFractionDigits(1)
 357                 .buildType();
 358         final UnionTypeBuilder unionTypeBuilder1 = BaseTypes.unionTypeBuilder(Q_NAME);
 359         final UnionTypeBuilder unionTypeBuilder2 = BaseTypes.unionTypeBuilder(Q_NAME);
 360         unionTypeBuilder1.addType(baseDecimalType1);
 361         unionTypeBuilder2.addType(baseDecimalType2);
 362         final BaseUnionType baseUnionType1 = (BaseUnionType)unionTypeBuilder1.build();
 363         final BaseUnionType baseUnionType2 = (BaseUnionType)unionTypeBuilder2.build();
 364         hashCodeEqualsToStringTest(baseUnionType1, baseUnionType2);
 365         assertEquals(baseUnionType1.getTypes(), baseUnionType2.getTypes());
 366
 367         final DerivedUnionType derivedUnionType1 = (DerivedUnionType)DerivedTypes
 368                 .derivedTypeBuilder(baseUnionType1, Q_NAME).build();
 369         final DerivedUnionType derivedUnionType2 = (DerivedUnionType)DerivedTypes
 370                 .derivedTypeBuilder(baseUnionType2, Q_NAME).build();
 371         hashCodeEqualsToStringTest(derivedUnionType1, derivedUnionType2);
 372
 373         restrictedBuilderTest(RestrictedTypes.newUnionBuilder(baseUnionType1, Q_NAME),
 374                 RestrictedTypes.newUnionBuilder(baseUnionType2, Q_NAME));
 375         concreteBuilderTest(baseUnionType1, derivedUnionType1);
 376     }
 377
 378     @Test
 379     public void abstractTypeDefinitionQnameTest() {
 380         final AbstractTypeDefinition<?> abstractTypeDefinition = (AbstractTypeDefinition<?>)
 381             BaseTypes.decimalTypeBuilder(Q_NAME).setFractionDigits(1).buildType();
 382         assertEquals(abstractTypeDefinition.getQName(), Q_NAME);
 383     }
 384
 385     @Test
 386     public void abstractDerivedTypeTest() {
 387         final BaseBinaryType baseBinaryType1 = BaseBinaryType.INSTANCE;
 388         final AbstractDerivedType<?> abstractDerivedType = (AbstractDerivedType<?>)
 389             DerivedTypes.derivedTypeBuilder(baseBinaryType1, Q_NAME).build();
 390         assertEquals(Optional.empty(), abstractDerivedType.getDescription());
 391         assertEquals(Optional.empty(), abstractDerivedType.getReference());
 392         assertEquals(Status.CURRENT, abstractDerivedType.getStatus());
 393     }
 394
 395     @Test
 396     public void concreteTypeBuilderBuildTest() {
 397         final BaseEnumerationType baseEnumerationType1 = (BaseEnumerationType)
 398             BaseTypes.enumerationTypeBuilder(Q_NAME).build();
 399         final ConcreteTypeBuilder<?> concreteTypeBuilder = ConcreteTypes.concreteTypeBuilder(
 400                 baseEnumerationType1, Q_NAME);
 401         final TypeDefinition<?> typeDefinition = concreteTypeBuilder.build();
 402         assertNotNull(typeDefinition);
 403     }
 404
 405     @Test
 406     public void constraintTypeBuilderTest() throws InvalidLengthConstraintException {
 407         final BaseBinaryType baseBinaryType = (BaseBinaryType)BaseTypes.binaryType();
 408         final LengthRestrictedTypeBuilder<?> lengthRestrictedTypeBuilder = RestrictedTypes
 409                 .newBinaryBuilder(baseBinaryType, Q_NAME);
 410         final Long min = (long) 0;
 411         final UnresolvedNumber max = UnresolvedNumber.max();
 412         final List<ValueRange> lengthArrayList = ImmutableList.of(ValueRange.of(min, max));
 413         lengthRestrictedTypeBuilder.setLengthConstraint(mock(ConstraintMetaDefinition.class), lengthArrayList);
 414         final TypeDefinition<?> typeDefinition = lengthRestrictedTypeBuilder.buildType();
 415         assertNotNull(typeDefinition);
 416
 417         final Int8TypeDefinition integerTypeDefinition8 = BaseTypes.int8Type();
 418         final RangeRestrictedTypeBuilder<?, ?> rangeRestrictedTypeBuilder = RestrictedTypes.newInt8Builder(
 419             integerTypeDefinition8, Q_NAME);
 420         rangeRestrictedTypeBuilder.setRangeConstraint(mock(ConstraintMetaDefinition.class), lengthArrayList);
 421         final TypeDefinition<?> typeDefinition1 = rangeRestrictedTypeBuilder.buildType();
 422         assertNotNull(typeDefinition1);
 423     }
 424
 425     @Test
 426     public void exceptionTest() {
 427         final UnresolvedNumber min = UnresolvedNumber.min();
 428         final UnresolvedNumber max = UnresolvedNumber.max();
 429         final EnumPair enumPair = EnumPairBuilder.create("enum1", 1).setDescription("description")
 430                 .setReference("reference").setUnknownSchemaNodes(mock(UnknownSchemaNode.class)).build();
 431
 432         final RangeSet<Integer> rangeset = ImmutableRangeSet.of(Range.closed(1, 2));
 433         final InvalidRangeConstraintException invalidRangeConstraintException = new InvalidRangeConstraintException(
 434                 rangeset, "error msg", "other important messages");
 435         assertSame(rangeset, invalidRangeConstraintException.getOffendingRanges());
 436
 437         final InvalidBitDefinitionException invalidBitDefinitionException = new InvalidBitDefinitionException(
 438                 BIT_A, "error msg", "other important messages");
 439         assertEquals(invalidBitDefinitionException.getOffendingBit(), BIT_A);
 440
 441         final InvalidEnumDefinitionException invalidEnumDefinitionException = new InvalidEnumDefinitionException(
 442                 enumPair, "error msg", "other important messages");
 443         assertEquals(invalidEnumDefinitionException.getOffendingEnum(), enumPair);
 444     }
 445
 446     @Test
 447     public void identityrefTypeBuilderException() {
 448         final IdentityrefTypeBuilder builder = BaseTypes.identityrefTypeBuilder(Q_NAME);
 449         assertThrows(IllegalStateException.class, () -> builder.build());
 450     }
 451
 452     @Test
 453     public void invalidBitDefinitionExceptionTest() {
 454         final BitsTypeBuilder bitsTypeBuilder = BaseTypes.bitsTypeBuilder(Q_NAME)
 455                 .addBit(BIT_A)
 456                 .addBit(BitBuilder.create("test-name-1", Uint32.valueOf(55)).build());
 457
 458         assertThrows(InvalidBitDefinitionException.class, () -> bitsTypeBuilder.build());
 459     }
 460
 461     @Test
 462     public void invalidEnumDefinitionExceptionTest() {
 463         final UnknownSchemaNode unknown = mock(UnknownSchemaNode.class);
 464         final EnumPair enumPair1 = EnumPairBuilder.create("enum1", 1).setDescription("description")
 465                 .setReference("reference").setUnknownSchemaNodes(unknown).build();
 466         final EnumPair enumPair2 = EnumPairBuilder.create("enum", 1).setDescription("description")
 467                 .setReference("reference").setUnknownSchemaNodes(unknown).build();
 468         final EnumerationTypeBuilder enumerationTypeBuilder = BaseTypes.enumerationTypeBuilder(Q_NAME);
 469         enumerationTypeBuilder.addEnum(enumPair1);
 470         enumerationTypeBuilder.addEnum(enumPair2);
 471
 472         assertThrows(InvalidEnumDefinitionException.class, () -> enumerationTypeBuilder.build());
 473     }
 474
 475     private static void hashCodeEqualsToStringTest(final TypeDefinition<?> type1, final TypeDefinition<?> type2) {
 476         assertEquals(type1.hashCode(), type2.hashCode());
 477         assertEquals(type1.toString(), type2.toString());
 478         assertTrue(type1.equals(type2));
 479     }
 480
 481     private static <T> void testInstance(final T type1, final T type2) {
 482         assertEquals(type1, type2);
 483     }
 484
 485     private static void restrictedBuilderTest(final Builder<?> typeBuilder1, final Builder<?> typeBuilder2) {
 486         final TypeDefinition<?> typeDefinition1 = ((AbstractRestrictedTypeBuilder<?>) typeBuilder1).buildType();
 487         final TypeDefinition<?> typeDefinition2 = ((AbstractRestrictedTypeBuilder<?>) typeBuilder2).buildType();
 488         hashCodeEqualsToStringTest(typeDefinition1, typeDefinition2);
 489     }
 490
 491     private static void concreteBuilderTest(final TypeDefinition<?> baseTypeDef,
 492             final TypeDefinition<?> derivedTypeDef) {
 493         final ConcreteTypeBuilder<?> concreteTypeBuilder = ConcreteTypes.concreteTypeBuilder(baseTypeDef, Q_NAME);
 494         final TypeDefinition<?> typeDefinition = concreteTypeBuilder.buildType();
 495         assertEquals(typeDefinition.getBaseType(), derivedTypeDef.getBaseType());
 496     }
 497 }