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