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.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;
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();
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());
62 final DerivedBinaryType derivedBinaryType1 = (DerivedBinaryType)DerivedTypes.derivedTypeBuilder(baseBinaryType1,
64 final DerivedBinaryType derivedBinaryType2 = (DerivedBinaryType)DerivedTypes.derivedTypeBuilder(baseBinaryType2,
66 hashCodeEqualsToStringTest(derivedBinaryType1, derivedBinaryType2);
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);
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);
82 public void booleanTypeTest() {
83 final BaseBooleanType baseBooleanType1 = BaseBooleanType.INSTANCE;
84 final BaseBooleanType baseBooleanType2 = (BaseBooleanType)BaseTypes.booleanType();
85 hashCodeEqualsToStringTest(baseBooleanType1, baseBooleanType2);
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);
93 restrictedBuilderTest(RestrictedTypes.newBooleanBuilder(baseBooleanType1, SCHEMA_PATH), RestrictedTypes
94 .newBooleanBuilder(baseBooleanType2, SCHEMA_PATH));
95 concreteBuilderTest(baseBooleanType1, derivedBooleanType1);
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);
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);
116 restrictedBuilderTest(RestrictedTypes.newIdentityrefBuilder(derivedIdentityrefType1, SCHEMA_PATH),
117 RestrictedTypes.newIdentityrefBuilder(derivedIdentityrefType2, SCHEMA_PATH));
121 public void decimalTypeTest() {
122 final BaseDecimalType baseDecimalType1 = (BaseDecimalType)BaseTypes.decimalTypeBuilder(SCHEMA_PATH)
123 .setFractionDigits(1)
125 final BaseDecimalType baseDecimalType2 = (BaseDecimalType)BaseTypes.decimalTypeBuilder(SCHEMA_PATH)
126 .setFractionDigits(1)
128 hashCodeEqualsToStringTest(baseDecimalType1, baseDecimalType2);
129 assertEquals(baseDecimalType1.getFractionDigits(), baseDecimalType2.getFractionDigits());
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);
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);
146 public void emptyTypeTest() {
147 final BaseEmptyType baseEmptyType1 = BaseEmptyType.INSTANCE;
148 final BaseEmptyType baseEmptyType2 = (BaseEmptyType)BaseTypes.emptyType();
149 hashCodeEqualsToStringTest(baseEmptyType1, baseEmptyType2);
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);
157 restrictedBuilderTest(RestrictedTypes.newEmptyBuilder(baseEmptyType1, SCHEMA_PATH),
158 RestrictedTypes.newEmptyBuilder(baseEmptyType2, SCHEMA_PATH));
159 concreteBuilderTest(baseEmptyType1, derivedEmptyType1);
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());
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);
176 final InstanceIdentifierTypeBuilder instanceIdentifierBuilder1 = RestrictedTypes
177 .newInstanceIdentifierBuilder(baseInstanceIdentifierType1, SCHEMA_PATH);
178 instanceIdentifierBuilder1.setRequireInstance(true);
179 final InstanceIdentifierTypeDefinition instanceIdentifierTypeDefinition1 = instanceIdentifierBuilder1
181 final InstanceIdentifierTypeBuilder instanceIdentifierBuilder2 = RestrictedTypes
182 .newInstanceIdentifierBuilder(baseInstanceIdentifierType1, SCHEMA_PATH);
183 instanceIdentifierBuilder2.setRequireInstance(true);
184 final InstanceIdentifierTypeDefinition instanceIdentifierTypeDefinition2 = instanceIdentifierBuilder2
186 hashCodeEqualsToStringTest(instanceIdentifierTypeDefinition2, instanceIdentifierTypeDefinition1);
187 concreteBuilderTest(baseInstanceIdentifierType1, derivedInstanceIdentifierType1);
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);
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);
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));
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);
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);
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);
244 final DerivedTypeBuilder<?> derivedTypeBuilder = DerivedTypes.derivedTypeBuilder(integerTypeDefinition8,
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");
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());
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);
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);
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);
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());
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);
300 restrictedBuilderTest(RestrictedTypes.newBitsBuilder(bitsTypeDefinition1, SCHEMA_PATH),
301 RestrictedTypes.newBitsBuilder(bitsTypeDefinition2, SCHEMA_PATH));
302 concreteBuilderTest(bitsTypeDefinition1, derivedBitsType1);
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());
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);
320 restrictedBuilderTest(RestrictedTypes.newEnumerationBuilder(baseEnumerationType1, SCHEMA_PATH),
321 RestrictedTypes.newEnumerationBuilder(baseEnumerationType2, SCHEMA_PATH));
322 concreteBuilderTest(baseEnumerationType1, derivedEnumerationType1);
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);
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);
342 restrictedBuilderTest(RestrictedTypes.newLeafrefBuilder(baseLeafrefType1, SCHEMA_PATH),
343 RestrictedTypes.newLeafrefBuilder(baseLeafrefType2, SCHEMA_PATH));
344 concreteBuilderTest(baseLeafrefType1, derivedLeafrefType1);
348 public void unionTypeTest() throws IllegalAccessException, InstantiationException {
349 final BaseDecimalType baseDecimalType1 = (BaseDecimalType)BaseTypes.decimalTypeBuilder(SCHEMA_PATH)
350 .setFractionDigits(1)
352 final BaseDecimalType baseDecimalType2 = (BaseDecimalType)BaseTypes.decimalTypeBuilder(SCHEMA_PATH)
353 .setFractionDigits(1)
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());
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);
370 restrictedBuilderTest(RestrictedTypes.newUnionBuilder(baseUnionType1, SCHEMA_PATH),
371 RestrictedTypes.newUnionBuilder(baseUnionType2, SCHEMA_PATH));
372 concreteBuilderTest(baseUnionType1, derivedUnionType1);
376 public void abstractTypeDefinitionQnameTest() {
377 final AbstractTypeDefinition<?> abstractTypeDefinition = (AbstractTypeDefinition<?>)
378 BaseTypes.decimalTypeBuilder(SCHEMA_PATH).setFractionDigits(1).buildType();
379 assertEquals(abstractTypeDefinition.getQName(), Q_NAME);
383 public void abstractDerivedTypeTest() {
384 final BaseBinaryType baseBinaryType1 = BaseBinaryType.INSTANCE;
385 final AbstractDerivedType<?> abstractDerivedType = (AbstractDerivedType<?>)
386 DerivedTypes.derivedTypeBuilder(baseBinaryType1, SCHEMA_PATH).build();
387 assertEquals(abstractDerivedType.getDescription(), null);
388 assertEquals(abstractDerivedType.getReference(), null);
389 assertEquals(abstractDerivedType.getStatus().toString(), "CURRENT");
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));
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);
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);
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);
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(),
440 final EnumPair enumPair = EnumPairBuilder.create("enum1", 1).setDescription("description")
441 .setReference("reference").setUnknownSchemaNodes(mock(UnknownSchemaNode.class)).build();
443 final InvalidRangeConstraintException invalidRangeConstraintException = new InvalidRangeConstraintException(
444 rangeConstraint, "error msg", "other important messages");
445 assertEquals(invalidRangeConstraintException.getOffendingConstraint(), rangeConstraint);
447 final InvalidBitDefinitionException invalidBitDefinitionException = new InvalidBitDefinitionException(
448 BIT_A, "error msg", "other important messages");
449 assertEquals(invalidBitDefinitionException.getOffendingBit(), BIT_A);
451 final InvalidEnumDefinitionException invalidEnumDefinitionException = new InvalidEnumDefinitionException(
452 enumPair, "error msg", "other important messages");
453 assertEquals(invalidEnumDefinitionException.getOffendingEnum(), enumPair);
456 @Test(expected = NullPointerException.class)
457 public void identityrefTypeBuilderException() {
458 BaseTypes.identityrefTypeBuilder(SCHEMA_PATH).build();
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();
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();
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));
490 private static <T> void testInstance(final T type1, final T type2) {
491 assertEquals(type1, type2);
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);
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());