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