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