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
8 package org.opendaylight.yangtools.yang.model.ri.type;
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.assertThrows;
15 import static org.junit.Assert.assertTrue;
16 import static org.mockito.Mockito.doReturn;
17 import static org.mockito.Mockito.mock;
19 import com.google.common.collect.ImmutableList;
20 import com.google.common.collect.ImmutableRangeSet;
21 import com.google.common.collect.Range;
22 import com.google.common.collect.RangeSet;
23 import java.util.List;
24 import java.util.Optional;
25 import org.junit.Test;
26 import org.opendaylight.yangtools.concepts.Builder;
27 import org.opendaylight.yangtools.yang.common.QName;
28 import org.opendaylight.yangtools.yang.common.Uint32;
29 import org.opendaylight.yangtools.yang.model.api.ConstraintMetaDefinition;
30 import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
31 import org.opendaylight.yangtools.yang.model.api.PathExpression;
32 import org.opendaylight.yangtools.yang.model.api.Status;
33 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
34 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
35 import org.opendaylight.yangtools.yang.model.api.stmt.UnresolvedNumber;
36 import org.opendaylight.yangtools.yang.model.api.stmt.ValueRange;
37 import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
38 import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
39 import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition.Bit;
40 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair;
41 import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
42 import org.opendaylight.yangtools.yang.model.api.type.InstanceIdentifierTypeDefinition;
43 import org.opendaylight.yangtools.yang.model.api.type.Int16TypeDefinition;
44 import org.opendaylight.yangtools.yang.model.api.type.Int32TypeDefinition;
45 import org.opendaylight.yangtools.yang.model.api.type.Int64TypeDefinition;
46 import org.opendaylight.yangtools.yang.model.api.type.Int8TypeDefinition;
47 import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
48 import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
49 import org.opendaylight.yangtools.yang.model.api.type.Uint16TypeDefinition;
50 import org.opendaylight.yangtools.yang.model.api.type.Uint32TypeDefinition;
51 import org.opendaylight.yangtools.yang.model.api.type.Uint64TypeDefinition;
52 import org.opendaylight.yangtools.yang.model.api.type.Uint8TypeDefinition;
54 public class TypeTest {
55 private static final QName Q_NAME = QName.create("test.namespace", "2016-01-01", "test-name");
56 private static final Bit BIT_A = BitBuilder.create(Q_NAME.getLocalName(), Uint32.valueOf(55L))
57 .setDescription("description")
58 .setReference("reference")
62 public void binaryTypeTest() {
63 final BaseBinaryType baseBinaryType1 = BaseBinaryType.INSTANCE;
64 final BaseBinaryType baseBinaryType2 = (BaseBinaryType)BaseTypes.binaryType();
65 hashCodeEqualsToStringTest(baseBinaryType1, baseBinaryType2);
66 assertEquals(baseBinaryType1.getLengthConstraint(), baseBinaryType2.getLengthConstraint());
68 final DerivedBinaryType derivedBinaryType1 = (DerivedBinaryType)DerivedTypes.derivedTypeBuilder(baseBinaryType1,
70 final DerivedBinaryType derivedBinaryType2 = (DerivedBinaryType)DerivedTypes.derivedTypeBuilder(baseBinaryType2,
72 hashCodeEqualsToStringTest(derivedBinaryType1, derivedBinaryType2);
74 final RestrictedBinaryType restrictedBinaryType1 = (RestrictedBinaryType)RestrictedTypes.newBinaryBuilder(
75 baseBinaryType1, Q_NAME).buildType();
76 final RestrictedBinaryType restrictedBinaryType2 = (RestrictedBinaryType)RestrictedTypes.newBinaryBuilder(
77 baseBinaryType2, Q_NAME).buildType();
78 hashCodeEqualsToStringTest(restrictedBinaryType1, restrictedBinaryType2);
80 final LengthRestrictedTypeBuilder<BinaryTypeDefinition> lengthRestrictedTypeBuilder = RestrictedTypes
81 .newBinaryBuilder(baseBinaryType1, Q_NAME);
82 final BaseBinaryType baseBinaryType = (BaseBinaryType)lengthRestrictedTypeBuilder.build();
83 assertEquals(baseBinaryType, baseBinaryType1);
84 concreteBuilderTest(baseBinaryType1, derivedBinaryType1);
88 public void booleanTypeTest() {
89 final BaseBooleanType baseBooleanType1 = BaseBooleanType.INSTANCE;
90 final BaseBooleanType baseBooleanType2 = (BaseBooleanType)BaseTypes.booleanType();
91 hashCodeEqualsToStringTest(baseBooleanType1, baseBooleanType2);
93 final DerivedBooleanType derivedBooleanType1 = (DerivedBooleanType)DerivedTypes.derivedTypeBuilder(
94 baseBooleanType1, Q_NAME).build();
95 final DerivedBooleanType derivedBooleanType2 = (DerivedBooleanType)DerivedTypes.derivedTypeBuilder(
96 baseBooleanType1, Q_NAME).build();
97 hashCodeEqualsToStringTest(derivedBooleanType1, derivedBooleanType2);
99 restrictedBuilderTest(RestrictedTypes.newBooleanBuilder(baseBooleanType1, Q_NAME), RestrictedTypes
100 .newBooleanBuilder(baseBooleanType2, Q_NAME));
101 concreteBuilderTest(baseBooleanType1, derivedBooleanType1);
105 public void identityrefTypeTest() {
106 final IdentityrefTypeBuilder identityrefTypeBuilder1 = BaseTypes.identityrefTypeBuilder(Q_NAME);
107 final IdentitySchemaNode identitySchemaNode = mock(IdentitySchemaNode.class);
108 doReturn("identitySchemaNode").when(identitySchemaNode).toString();
109 identityrefTypeBuilder1.addIdentity(identitySchemaNode);
110 final IdentityrefTypeDefinition identityrefTypeDefinition1 = identityrefTypeBuilder1.build();
111 final IdentityrefTypeBuilder identityrefTypeBuilder2 = BaseTypes.identityrefTypeBuilder(Q_NAME);
112 identityrefTypeBuilder2.addIdentity(identitySchemaNode);
113 final IdentityrefTypeDefinition identityrefTypeDefinition2 = identityrefTypeBuilder2.build();
114 hashCodeEqualsToStringTest(identityrefTypeDefinition1, identityrefTypeDefinition2);
116 final DerivedIdentityrefType derivedIdentityrefType1 = (DerivedIdentityrefType)DerivedTypes.derivedTypeBuilder(
117 identityrefTypeDefinition1, Q_NAME).build();
118 final DerivedIdentityrefType derivedIdentityrefType2 = (DerivedIdentityrefType)DerivedTypes.derivedTypeBuilder(
119 identityrefTypeDefinition2, Q_NAME).build();
120 hashCodeEqualsToStringTest(derivedIdentityrefType1, derivedIdentityrefType2);
121 concreteBuilderTest(identityrefTypeDefinition1, derivedIdentityrefType1);
123 restrictedBuilderTest(RestrictedTypes.newIdentityrefBuilder(derivedIdentityrefType1, Q_NAME),
124 RestrictedTypes.newIdentityrefBuilder(derivedIdentityrefType2, Q_NAME));
128 public void decimalTypeTest() {
129 final BaseDecimalType baseDecimalType1 = (BaseDecimalType)BaseTypes.decimalTypeBuilder(Q_NAME)
130 .setFractionDigits(1)
132 final BaseDecimalType baseDecimalType2 = (BaseDecimalType)BaseTypes.decimalTypeBuilder(Q_NAME)
133 .setFractionDigits(1)
135 hashCodeEqualsToStringTest(baseDecimalType1, baseDecimalType2);
136 assertEquals(baseDecimalType1.getFractionDigits(), baseDecimalType2.getFractionDigits());
138 final DerivedDecimalType derivedDecimalType1 = (DerivedDecimalType)DerivedTypes
139 .derivedTypeBuilder(baseDecimalType1, Q_NAME).build();
140 final DerivedDecimalType derivedDecimalType2 = (DerivedDecimalType)DerivedTypes
141 .derivedTypeBuilder(baseDecimalType1, Q_NAME).build();
142 hashCodeEqualsToStringTest(derivedDecimalType1, derivedDecimalType2);
144 final RestrictedDecimalType restrictedDecimalType1 = (RestrictedDecimalType)
145 RestrictedTypes.newDecima64Builder(baseDecimalType1, Q_NAME).buildType();
146 final RestrictedDecimalType restrictedDecimalType2 = (RestrictedDecimalType)
147 RestrictedTypes.newDecima64Builder(baseDecimalType2, Q_NAME).buildType();
148 hashCodeEqualsToStringTest(restrictedDecimalType1, restrictedDecimalType2);
149 concreteBuilderTest(baseDecimalType1, derivedDecimalType1);
153 public void emptyTypeTest() {
154 final BaseEmptyType baseEmptyType1 = BaseEmptyType.INSTANCE;
155 final BaseEmptyType baseEmptyType2 = (BaseEmptyType)BaseTypes.emptyType();
156 hashCodeEqualsToStringTest(baseEmptyType1, baseEmptyType2);
158 final DerivedEmptyType derivedEmptyType1 = (DerivedEmptyType)DerivedTypes.derivedTypeBuilder(
159 baseEmptyType1, Q_NAME).build();
160 final DerivedEmptyType derivedEmptyType2 = (DerivedEmptyType)DerivedTypes.derivedTypeBuilder(
161 baseEmptyType2, Q_NAME).build();
162 hashCodeEqualsToStringTest(derivedEmptyType1, derivedEmptyType2);
164 restrictedBuilderTest(RestrictedTypes.newEmptyBuilder(baseEmptyType1, Q_NAME),
165 RestrictedTypes.newEmptyBuilder(baseEmptyType2, Q_NAME));
166 concreteBuilderTest(baseEmptyType1, derivedEmptyType1);
170 public void instanceIdentifierTypeTest() {
171 final BaseInstanceIdentifierType baseInstanceIdentifierType1 = BaseInstanceIdentifierType.INSTANCE;
172 final BaseInstanceIdentifierType baseInstanceIdentifierType2 = (BaseInstanceIdentifierType)BaseTypes
173 .instanceIdentifierType();
174 hashCodeEqualsToStringTest(baseInstanceIdentifierType1, baseInstanceIdentifierType2);
175 assertFalse(baseInstanceIdentifierType1.requireInstance());
177 final DerivedInstanceIdentifierType derivedInstanceIdentifierType1 = (DerivedInstanceIdentifierType)
178 DerivedTypes.derivedTypeBuilder(baseInstanceIdentifierType1, Q_NAME).build();
179 final DerivedInstanceIdentifierType derivedInstanceIdentifierType2 = (DerivedInstanceIdentifierType)
180 DerivedTypes.derivedTypeBuilder(baseInstanceIdentifierType2, Q_NAME).build();
181 hashCodeEqualsToStringTest(derivedInstanceIdentifierType1, derivedInstanceIdentifierType2);
183 final InstanceIdentifierTypeBuilder instanceIdentifierBuilder1 = RestrictedTypes
184 .newInstanceIdentifierBuilder(baseInstanceIdentifierType1, Q_NAME);
185 instanceIdentifierBuilder1.setRequireInstance(true);
186 final InstanceIdentifierTypeDefinition instanceIdentifierTypeDefinition1 = instanceIdentifierBuilder1
188 final InstanceIdentifierTypeBuilder instanceIdentifierBuilder2 = RestrictedTypes
189 .newInstanceIdentifierBuilder(baseInstanceIdentifierType1, Q_NAME);
190 instanceIdentifierBuilder2.setRequireInstance(true);
191 final InstanceIdentifierTypeDefinition instanceIdentifierTypeDefinition2 = instanceIdentifierBuilder2
193 hashCodeEqualsToStringTest(instanceIdentifierTypeDefinition2, instanceIdentifierTypeDefinition1);
194 concreteBuilderTest(baseInstanceIdentifierType1, derivedInstanceIdentifierType1);
198 public void integerTypeTest() {
199 final Int8TypeDefinition integerTypeDefinition8 = BaseTypes.int8Type();
200 final Int16TypeDefinition integerTypeDefinition16 = BaseTypes.int16Type();
201 final Int32TypeDefinition integerTypeDefinition32 = BaseTypes.int32Type();
202 final Int64TypeDefinition integerTypeDefinition64 = BaseTypes.int64Type();
203 testInstance(BaseInt8Type.INSTANCE, integerTypeDefinition8);
204 testInstance(BaseInt16Type.INSTANCE, integerTypeDefinition16);
205 testInstance(BaseInt32Type.INSTANCE, integerTypeDefinition32);
206 testInstance(BaseInt64Type.INSTANCE, integerTypeDefinition64);
208 final RestrictedInt8Type restrictedIntegerType1 = (RestrictedInt8Type)RestrictedTypes.newInt8Builder(
209 integerTypeDefinition8, Q_NAME).buildType();
210 final RestrictedInt8Type restrictedIntegerType2 = (RestrictedInt8Type)RestrictedTypes.newInt8Builder(
211 BaseInt8Type.INSTANCE, Q_NAME).buildType();
212 hashCodeEqualsToStringTest(restrictedIntegerType1, restrictedIntegerType2);
214 final Uint8TypeDefinition integerTypeDefinitionu8 = BaseTypes.uint8Type();
215 final Uint16TypeDefinition integerTypeDefinitionu16 = BaseTypes.uint16Type();
216 final Uint32TypeDefinition integerTypeDefinitionu32 = BaseTypes.uint32Type();
217 final Uint64TypeDefinition integerTypeDefinitionu64 = BaseTypes.uint64Type();
218 testInstance(BaseUint8Type.INSTANCE, integerTypeDefinitionu8);
219 testInstance(BaseUint16Type.INSTANCE, integerTypeDefinitionu16);
220 testInstance(BaseUint32Type.INSTANCE, integerTypeDefinitionu32);
221 testInstance(BaseUint64Type.INSTANCE, BaseTypes.baseTypeOf(integerTypeDefinitionu64));
223 final DerivedInt8Type derivedIntegerType1 = (DerivedInt8Type)DerivedTypes
224 .derivedTypeBuilder(integerTypeDefinition8, Q_NAME).build();
225 final DerivedInt8Type derivedIntegerType2 = (DerivedInt8Type)DerivedTypes
226 .derivedTypeBuilder(BaseInt8Type.INSTANCE, Q_NAME).build();
227 hashCodeEqualsToStringTest(derivedIntegerType1, derivedIntegerType2);
229 final DerivedUint8Type derivedUnsignedType1 = (DerivedUint8Type)DerivedTypes
230 .derivedTypeBuilder(integerTypeDefinitionu8, Q_NAME).build();
231 final DerivedUint8Type derivedUnsignedType2 = (DerivedUint8Type)DerivedTypes
232 .derivedTypeBuilder(BaseUint8Type.INSTANCE, Q_NAME).build();
233 hashCodeEqualsToStringTest(derivedUnsignedType1, derivedUnsignedType2);
235 final RestrictedUint8Type restrictedUnsignedType1 = (RestrictedUint8Type)RestrictedTypes
236 .newUint8Builder(integerTypeDefinitionu8, Q_NAME).buildType();
237 final RestrictedUint8Type restrictedUnsignedType2 = (RestrictedUint8Type)RestrictedTypes
238 .newUint8Builder(BaseUint8Type.INSTANCE, Q_NAME).buildType();
239 hashCodeEqualsToStringTest(restrictedUnsignedType1, restrictedUnsignedType2);
240 concreteBuilderTest(integerTypeDefinition8, derivedIntegerType1);
241 concreteBuilderTest(integerTypeDefinitionu8, derivedUnsignedType2);
243 final DerivedTypeBuilder<?> derivedTypeBuilder = DerivedTypes.derivedTypeBuilder(integerTypeDefinition8,
245 derivedTypeBuilder.setDefaultValue(1);
246 derivedTypeBuilder.setDescription("test-description");
247 derivedTypeBuilder.setReference("test-reference");
248 derivedTypeBuilder.setUnits("Int");
249 derivedTypeBuilder.setStatus(Status.CURRENT);
250 assertEquals(derivedTypeBuilder.getStatus(), Status.CURRENT);
251 assertEquals(derivedTypeBuilder.getDescription(), "test-description");
252 assertEquals(derivedTypeBuilder.getReference(), "test-reference");
253 assertEquals(derivedTypeBuilder.getUnits(), "Int");
257 public void stringTypeTest() {
258 final BaseStringType baseStringType1 = BaseStringType.INSTANCE;
259 final BaseStringType baseStringType2 = (BaseStringType)BaseTypes.stringType();
260 hashCodeEqualsToStringTest(baseStringType1, baseStringType2);
261 assertEquals(baseStringType1.getLengthConstraint(), baseStringType2.getLengthConstraint());
262 assertEquals(baseStringType1.getPatternConstraints(), baseStringType2.getPatternConstraints());
264 final DerivedStringType derivedStringType1 = (DerivedStringType)
265 DerivedTypes.derivedTypeBuilder(baseStringType1, Q_NAME).build();
266 final DerivedStringType derivedStringType2 = (DerivedStringType)
267 DerivedTypes.derivedTypeBuilder(baseStringType2, Q_NAME).build();
268 hashCodeEqualsToStringTest(derivedStringType1, derivedStringType2);
270 final RestrictedStringType restrictedStringType1 = (RestrictedStringType)RestrictedTypes
271 .newStringBuilder(baseStringType1, Q_NAME).buildType();
272 final RestrictedStringType restrictedStringType2 = (RestrictedStringType)RestrictedTypes
273 .newStringBuilder(baseStringType2, Q_NAME).buildType();
274 hashCodeEqualsToStringTest(restrictedStringType1, restrictedStringType2);
275 concreteBuilderTest(baseStringType1, derivedStringType1);
277 final StringTypeBuilder stringTypeBuilder = new StringTypeBuilder(baseStringType1, Q_NAME);
278 stringTypeBuilder.addPatternConstraint(mock(PatternConstraint.class));
279 final StringTypeDefinition stringTypeDefinition = stringTypeBuilder.buildType();
280 assertNotNull(stringTypeDefinition);
284 public void bitsTypeTest() {
285 final BitsTypeBuilder bitsTypeBuilder = BaseTypes.bitsTypeBuilder(Q_NAME);
286 bitsTypeBuilder.addBit(BIT_A);
287 final BitsTypeDefinition bitsTypeDefinition1 = bitsTypeBuilder.build();
288 final BitsTypeDefinition bitsTypeDefinition2 = bitsTypeBuilder.build();
289 hashCodeEqualsToStringTest(bitsTypeDefinition1, bitsTypeDefinition2);
290 assertEquals(bitsTypeDefinition1.getBits(), bitsTypeDefinition1.getBits());
292 final DerivedBitsType derivedBitsType1 = (DerivedBitsType)DerivedTypes
293 .derivedTypeBuilder(bitsTypeDefinition1, Q_NAME).build();
294 final DerivedBitsType derivedBitsType2 = (DerivedBitsType)DerivedTypes
295 .derivedTypeBuilder(bitsTypeDefinition2, Q_NAME).build();
296 hashCodeEqualsToStringTest(derivedBitsType1, derivedBitsType2);
298 restrictedBuilderTest(RestrictedTypes.newBitsBuilder(bitsTypeDefinition1, Q_NAME),
299 RestrictedTypes.newBitsBuilder(bitsTypeDefinition2, Q_NAME));
300 concreteBuilderTest(bitsTypeDefinition1, derivedBitsType1);
304 public void enumerationTypeTest() {
305 final BaseEnumerationType baseEnumerationType1 = (BaseEnumerationType)BaseTypes.enumerationTypeBuilder(Q_NAME)
307 final BaseEnumerationType baseEnumerationType2 = (BaseEnumerationType)BaseTypes.enumerationTypeBuilder(Q_NAME)
309 hashCodeEqualsToStringTest(baseEnumerationType1, baseEnumerationType2);
310 assertEquals(baseEnumerationType1.getValues(), baseEnumerationType2.getValues());
312 final DerivedEnumerationType derivedEnumerationType1 = (DerivedEnumerationType)DerivedTypes
313 .derivedTypeBuilder(baseEnumerationType1, Q_NAME).build();
314 final DerivedEnumerationType derivedEnumerationType2 = (DerivedEnumerationType)DerivedTypes
315 .derivedTypeBuilder(baseEnumerationType2, Q_NAME).build();
316 hashCodeEqualsToStringTest(derivedEnumerationType1, derivedEnumerationType2);
318 restrictedBuilderTest(RestrictedTypes.newEnumerationBuilder(baseEnumerationType1, Q_NAME),
319 RestrictedTypes.newEnumerationBuilder(baseEnumerationType2, Q_NAME));
320 concreteBuilderTest(baseEnumerationType1, derivedEnumerationType1);
324 public void leafrefTypeTest() {
325 final PathExpression expr = mock(PathExpression.class);
327 final LeafrefTypeBuilder leafrefTypeBuilder1 = BaseTypes.leafrefTypeBuilder(Q_NAME);
328 final LeafrefTypeBuilder leafrefTypeBuilder2 = BaseTypes.leafrefTypeBuilder(Q_NAME);
329 leafrefTypeBuilder1.setPathStatement(expr);
330 leafrefTypeBuilder2.setPathStatement(expr);
331 final BaseLeafrefType baseLeafrefType1 = (BaseLeafrefType)leafrefTypeBuilder1.build();
332 final BaseLeafrefType baseLeafrefType2 = (BaseLeafrefType)leafrefTypeBuilder1.build();
333 hashCodeEqualsToStringTest(baseLeafrefType1, baseLeafrefType2);
334 assertEquals(expr, baseLeafrefType1.getPathStatement());
336 final DerivedLeafrefType derivedLeafrefType1 = (DerivedLeafrefType)DerivedTypes
337 .derivedTypeBuilder(baseLeafrefType1, Q_NAME).build();
338 final DerivedLeafrefType derivedLeafrefType2 = (DerivedLeafrefType)DerivedTypes
339 .derivedTypeBuilder(baseLeafrefType2, Q_NAME).build();
340 hashCodeEqualsToStringTest(derivedLeafrefType1, derivedLeafrefType2);
342 restrictedBuilderTest(RestrictedTypes.newLeafrefBuilder(baseLeafrefType1, Q_NAME),
343 RestrictedTypes.newLeafrefBuilder(baseLeafrefType2, Q_NAME));
344 concreteBuilderTest(baseLeafrefType1, derivedLeafrefType1);
348 public void unionTypeTest() throws IllegalAccessException, InstantiationException {
349 final BaseDecimalType baseDecimalType1 = (BaseDecimalType)BaseTypes.decimalTypeBuilder(Q_NAME)
350 .setFractionDigits(1)
352 final BaseDecimalType baseDecimalType2 = (BaseDecimalType)BaseTypes.decimalTypeBuilder(Q_NAME)
353 .setFractionDigits(1)
355 final UnionTypeBuilder unionTypeBuilder1 = BaseTypes.unionTypeBuilder(Q_NAME);
356 final UnionTypeBuilder unionTypeBuilder2 = BaseTypes.unionTypeBuilder(Q_NAME);
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, Q_NAME).build();
366 final DerivedUnionType derivedUnionType2 = (DerivedUnionType)DerivedTypes
367 .derivedTypeBuilder(baseUnionType2, Q_NAME).build();
368 hashCodeEqualsToStringTest(derivedUnionType1, derivedUnionType2);
370 restrictedBuilderTest(RestrictedTypes.newUnionBuilder(baseUnionType1, Q_NAME),
371 RestrictedTypes.newUnionBuilder(baseUnionType2, Q_NAME));
372 concreteBuilderTest(baseUnionType1, derivedUnionType1);
376 public void abstractTypeDefinitionQnameTest() {
377 final AbstractTypeDefinition<?> abstractTypeDefinition = (AbstractTypeDefinition<?>)
378 BaseTypes.decimalTypeBuilder(Q_NAME).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, Q_NAME).build();
387 assertEquals(Optional.empty(), abstractDerivedType.getDescription());
388 assertEquals(Optional.empty(), abstractDerivedType.getReference());
389 assertEquals(Status.CURRENT, abstractDerivedType.getStatus());
393 public void concreteTypeBuilderBuildTest() {
394 final BaseEnumerationType baseEnumerationType1 = (BaseEnumerationType)
395 BaseTypes.enumerationTypeBuilder(Q_NAME).build();
396 final ConcreteTypeBuilder<?> concreteTypeBuilder = ConcreteTypes.concreteTypeBuilder(
397 baseEnumerationType1, Q_NAME);
398 final TypeDefinition<?> typeDefinition = concreteTypeBuilder.build();
399 assertNotNull(typeDefinition);
403 public void constraintTypeBuilderTest() throws InvalidLengthConstraintException {
404 final BaseBinaryType baseBinaryType = (BaseBinaryType)BaseTypes.binaryType();
405 final LengthRestrictedTypeBuilder<?> lengthRestrictedTypeBuilder = RestrictedTypes
406 .newBinaryBuilder(baseBinaryType, Q_NAME);
407 final Long min = (long) 0;
408 final UnresolvedNumber max = UnresolvedNumber.max();
409 final List<ValueRange> lengthArrayList = ImmutableList.of(ValueRange.of(min, max));
410 lengthRestrictedTypeBuilder.setLengthConstraint(mock(ConstraintMetaDefinition.class), lengthArrayList);
411 final TypeDefinition<?> typeDefinition = lengthRestrictedTypeBuilder.buildType();
412 assertNotNull(typeDefinition);
414 final Int8TypeDefinition integerTypeDefinition8 = BaseTypes.int8Type();
415 final RangeRestrictedTypeBuilder<?, ?> rangeRestrictedTypeBuilder = RestrictedTypes.newInt8Builder(
416 integerTypeDefinition8, Q_NAME);
417 rangeRestrictedTypeBuilder.setRangeConstraint(mock(ConstraintMetaDefinition.class), lengthArrayList);
418 final TypeDefinition<?> typeDefinition1 = rangeRestrictedTypeBuilder.buildType();
419 assertNotNull(typeDefinition1);
423 public void exceptionTest() {
424 final UnresolvedNumber min = UnresolvedNumber.min();
425 final UnresolvedNumber max = UnresolvedNumber.max();
426 final EnumPair enumPair = EnumPairBuilder.create("enum1", 1).setDescription("description")
427 .setReference("reference").setUnknownSchemaNodes(mock(UnknownSchemaNode.class)).build();
429 final RangeSet<Integer> rangeset = ImmutableRangeSet.of(Range.closed(1, 2));
430 final InvalidRangeConstraintException invalidRangeConstraintException = new InvalidRangeConstraintException(
431 rangeset, "error msg", "other important messages");
432 assertSame(rangeset, invalidRangeConstraintException.getOffendingRanges());
434 final InvalidBitDefinitionException invalidBitDefinitionException = new InvalidBitDefinitionException(
435 BIT_A, "error msg", "other important messages");
436 assertEquals(invalidBitDefinitionException.getOffendingBit(), BIT_A);
438 final InvalidEnumDefinitionException invalidEnumDefinitionException = new InvalidEnumDefinitionException(
439 enumPair, "error msg", "other important messages");
440 assertEquals(invalidEnumDefinitionException.getOffendingEnum(), enumPair);
444 public void identityrefTypeBuilderException() {
445 final IdentityrefTypeBuilder builder = BaseTypes.identityrefTypeBuilder(Q_NAME);
446 assertThrows(IllegalStateException.class, () -> builder.build());
450 public void invalidBitDefinitionExceptionTest() {
451 final BitsTypeBuilder bitsTypeBuilder = BaseTypes.bitsTypeBuilder(Q_NAME)
453 .addBit(BitBuilder.create("test-name-1", Uint32.valueOf(55)).build());
455 assertThrows(InvalidBitDefinitionException.class, () -> bitsTypeBuilder.build());
459 public void invalidEnumDefinitionExceptionTest() {
460 final UnknownSchemaNode unknown = mock(UnknownSchemaNode.class);
461 final EnumPair enumPair1 = EnumPairBuilder.create("enum1", 1).setDescription("description")
462 .setReference("reference").setUnknownSchemaNodes(unknown).build();
463 final EnumPair enumPair2 = EnumPairBuilder.create("enum", 1).setDescription("description")
464 .setReference("reference").setUnknownSchemaNodes(unknown).build();
465 final EnumerationTypeBuilder enumerationTypeBuilder = BaseTypes.enumerationTypeBuilder(Q_NAME);
466 enumerationTypeBuilder.addEnum(enumPair1);
467 enumerationTypeBuilder.addEnum(enumPair2);
469 assertThrows(InvalidEnumDefinitionException.class, () -> enumerationTypeBuilder.build());
472 private static void hashCodeEqualsToStringTest(final TypeDefinition<?> type1, final TypeDefinition<?> type2) {
473 assertEquals(type1.hashCode(), type2.hashCode());
474 assertEquals(type1.toString(), type2.toString());
475 assertTrue(type1.equals(type2));
478 private static <T> void testInstance(final T type1, final T type2) {
479 assertEquals(type1, type2);
482 private static void restrictedBuilderTest(final Builder<?> typeBuilder1, final Builder<?> typeBuilder2) {
483 final TypeDefinition<?> typeDefinition1 = ((AbstractRestrictedTypeBuilder<?>) typeBuilder1).buildType();
484 final TypeDefinition<?> typeDefinition2 = ((AbstractRestrictedTypeBuilder<?>) typeBuilder2).buildType();
485 hashCodeEqualsToStringTest(typeDefinition1, typeDefinition2);
488 private static void concreteBuilderTest(final TypeDefinition<?> baseTypeDef,
489 final TypeDefinition<?> derivedTypeDef) {
490 final ConcreteTypeBuilder<?> concreteTypeBuilder = ConcreteTypes.concreteTypeBuilder(baseTypeDef, Q_NAME);
491 final TypeDefinition<?> typeDefinition = concreteTypeBuilder.buildType();
492 assertEquals(typeDefinition.getBaseType(), derivedTypeDef.getBaseType());