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