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