From c3bb225b72f0d6201de21720ca378660d9fa8f30 Mon Sep 17 00:00:00 2001 From: Robert Varga Date: Mon, 30 Oct 2017 12:04:06 +0100 Subject: [PATCH] Update TypeDefinition design Use Optional to communicate presence of default value and units. Update call sites to do the right thing, also for previously-missed changes. Change-Id: Icfffb752507e2810a6afb157faa09d07680292cf Signed-off-by: Robert Varga --- .../yang/model/api/TypeDefinition.java | 27 +++-- .../model/export/SchemaContextEmitter.java | 23 ++-- .../EffectiveSchemaContextEmitterTest.java | 6 +- .../model/util/type/AbstractBaseType.java | 8 +- .../model/util/type/AbstractDerivedType.java | 8 +- .../util/type/AbstractRestrictedType.java | 4 +- .../model/util/type/ConcreteTypeBuilder.java | 3 +- .../model/util/type/DerivedTypeBuilder.java | 29 +++-- .../yang/model/util/type/TypeDefinitions.java | 55 ++++----- .../yang/model/util/BinaryTypeTest.java | 13 +-- .../yang/model/util/BitsTypeTest.java | 5 +- .../yang/model/util/BooleanTypeTest.java | 6 +- .../yang/model/util/EmptyTypeTest.java | 5 +- .../yangtools/yang/model/util/Int8Test.java | 12 +- .../yang/model/util/LeafrefTest.java | 5 +- .../yang/stmt/DeviationResolutionTest.java | 25 +++-- .../yang/stmt/EffectiveStatementTypeTest.java | 44 ++++---- .../yangtools/yang/stmt/GroupingTest.java | 8 +- .../yangtools/yang/stmt/ListTest.java | 3 +- .../yang/stmt/TypedefSubStmtsTest.java | 5 +- .../yangtools/yang/stmt/YangParserTest.java | 106 +++++++++--------- 21 files changed, 206 insertions(+), 194 deletions(-) diff --git a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/TypeDefinition.java b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/TypeDefinition.java index 53ec6ac3e1..341f78a120 100644 --- a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/TypeDefinition.java +++ b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/TypeDefinition.java @@ -7,6 +7,8 @@ */ package org.opendaylight.yangtools.yang.model.api; +import java.util.Optional; + /** * YANG statement typedef contains also substatements * - * This interface contains the methods for getting the values of the arguments - * of substatements mentioned above. + * This interface contains the methods for getting the values of the arguments of substatements mentioned above. + * Furthermore {@link LeafSchemaNode} and {@link LeafListSchemaNode} interfaces contribute to their internal type + * definitions. * * @param * type of the base type (YANG type substatement) which @@ -26,8 +29,7 @@ package org.opendaylight.yangtools.yang.model.api; */ public interface TypeDefinition> extends SchemaNode { /** - * Returns the base type from which this type is derived. If this is yang - * built-in type, returns null. + * Returns the base type from which this type is derived. If this is yang built-in type, returns null. * * @return value of <T> type which represents the base * type of instance of the TypeDefinition type or null, @@ -36,21 +38,18 @@ public interface TypeDefinition> extends SchemaNode T getBaseType(); /** - * Returns the unit which represents the value of the argument of the - * units substatement of the YANG typedef - * statement. + * Returns the unit which represents the value of the argument of the units substatement of the YANG + * typedef, leaf or leaf-list statements. * * @return string with units in which is type measured */ - String getUnits(); + Optional getUnits(); /** - * Returns the default value which represents the value of the argument of - * the default substatement of the YANG typedef - * statement. + * Returns the default value which represents the value of the argument of the default substatement + * of the YANG typedef or leaf statement. * - * @return instance of Object type which contains default value - * for typedef + * @return instance of Object type which contains default value for typedef */ - Object getDefaultValue(); + Optional getDefaultValue(); } diff --git a/yang/yang-model-export/src/main/java/org/opendaylight/yangtools/yang/model/export/SchemaContextEmitter.java b/yang/yang-model-export/src/main/java/org/opendaylight/yangtools/yang/model/export/SchemaContextEmitter.java index 989ecafcdf..aedcb8f716 100644 --- a/yang/yang-model-export/src/main/java/org/opendaylight/yangtools/yang/model/export/SchemaContextEmitter.java +++ b/yang/yang-model-export/src/main/java/org/opendaylight/yangtools/yang/model/export/SchemaContextEmitter.java @@ -10,7 +10,6 @@ package org.opendaylight.yangtools.yang.model.export; import com.google.common.annotations.Beta; import com.google.common.base.Preconditions; import com.google.common.base.Predicates; -import com.google.common.base.Strings; import com.google.common.collect.Collections2; import com.google.common.collect.Range; import com.google.common.collect.RangeSet; @@ -1332,10 +1331,8 @@ abstract class SchemaContextEmitter { } private void emitUnitsNode(@Nullable final String input) { - if (!Strings.isNullOrEmpty(input)) { - super.writer.startUnitsNode(input); - super.writer.endNode(); - } + super.writer.startUnitsNode(input); + super.writer.endNode(); } private void emitRevision(final Revision date) { @@ -1420,8 +1417,8 @@ abstract class SchemaContextEmitter { // Differentiate between derived type and existing type // name. emitTypeNodeDerived(typedef); - emitUnitsNode(typedef.getUnits()); - emitDefaultNode(typedef.getDefaultValue()); + typedef.getUnits().ifPresent(this::emitUnitsNode); + typedef.getDefaultValue().ifPresent(this::emitDefaultNode); emitDocumentedNode(typedef); emitUnknownStatementNodes(typedef.getUnknownSchemaNodes()); super.writer.endNode(); @@ -1598,10 +1595,8 @@ abstract class SchemaContextEmitter { } private void emitDefaultNode(@Nullable final Object object) { - if (object != null) { - super.writer.startDefaultNode(object.toString()); - super.writer.endNode(); - } + super.writer.startDefaultNode(object.toString()); + super.writer.endNode(); } private void emitEnumSpecification(final EnumTypeDefinition typeDefinition) { @@ -1791,9 +1786,9 @@ abstract class SchemaContextEmitter { child.getConstraints().getWhenCondition().ifPresent(this::emitWhen); // FIXME: BUG-2444: *(ifFeatureNode ) emitTypeNode(child.getPath(), child.getType()); - emitUnitsNode(child.getType().getUnits()); + child.getType().getUnits().ifPresent(this::emitUnitsNode); emitMustNodes(child.getConstraints().getMustConstraints()); - emitDefaultNode(child.getType().getDefaultValue()); + child.getType().getDefaultValue().ifPresent(this::emitDefaultNode); emitConfigNode(child.isConfiguration()); emitMandatoryNode(child.getConstraints().isMandatory()); emitDocumentedNode(child); @@ -1808,7 +1803,7 @@ abstract class SchemaContextEmitter { child.getConstraints().getWhenCondition().ifPresent(this::emitWhen); // FIXME: BUG-2444: *(ifFeatureNode ) emitTypeNode(child.getPath(), child.getType()); - emitUnitsNode(child.getType().getUnits()); + child.getType().getUnits().ifPresent(this::emitUnitsNode); // FIXME: BUG-2444: unitsNode /Optional emitMustNodes(child.getConstraints().getMustConstraints()); emitConfigNode(child.isConfiguration()); diff --git a/yang/yang-model-export/src/test/java/org/opendaylight/yangtools/yang/model/export/EffectiveSchemaContextEmitterTest.java b/yang/yang-model-export/src/test/java/org/opendaylight/yangtools/yang/model/export/EffectiveSchemaContextEmitterTest.java index 4a4e68aa80..58d1838da3 100644 --- a/yang/yang-model-export/src/test/java/org/opendaylight/yangtools/yang/model/export/EffectiveSchemaContextEmitterTest.java +++ b/yang/yang-model-export/src/test/java/org/opendaylight/yangtools/yang/model/export/EffectiveSchemaContextEmitterTest.java @@ -59,7 +59,7 @@ public class EffectiveSchemaContextEmitterTest { assertNotEquals(0, output.length()); final Document doc = YinExportTestUtils.loadDocument("/bugs/bug2444/yin-effective-emitter", module); - assertXMLEquals(doc, output); + assertXMLEquals(module.getName(), doc, output); } finally { byteArrayOutputStream.close(); bufferedOutputStream.close(); @@ -116,7 +116,7 @@ public class EffectiveSchemaContextEmitterTest { return outFile; } - private static void assertXMLEquals(final Document expectedXMLDoc, final String output) + private static void assertXMLEquals(final String name, final Document expectedXMLDoc, final String output) throws SAXException, IOException { final String expected = YinExportTestUtils.toString(expectedXMLDoc.getDocumentElement()); @@ -126,6 +126,6 @@ public class EffectiveSchemaContextEmitterTest { final Diff diff = new Diff(expected, output); diff.overrideElementQualifier(new ElementNameAndAttributeQualifier()); - XMLAssert.assertXMLEqual(diff, true); + XMLAssert.assertXMLEqual(name, diff, true); } } diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/AbstractBaseType.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/AbstractBaseType.java index 3d05a9b4ba..8080b32574 100644 --- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/AbstractBaseType.java +++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/AbstractBaseType.java @@ -32,13 +32,13 @@ abstract class AbstractBaseType> extends AbstractTyp } @Override - public final String getUnits() { - return null; + public final Optional getUnits() { + return Optional.empty(); } @Override - public final Object getDefaultValue() { - return null; + public final Optional getDefaultValue() { + return Optional.empty(); } @Override diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/AbstractDerivedType.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/AbstractDerivedType.java index eefc4a68b5..99feb4780d 100644 --- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/AbstractDerivedType.java +++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/AbstractDerivedType.java @@ -50,8 +50,8 @@ abstract class AbstractDerivedType> extends Abstract } @Override - public final Object getDefaultValue() { - return defaultValue != null ? defaultValue : baseType.getDefaultValue(); + public final Optional getDefaultValue() { + return defaultValue != null ? Optional.of(defaultValue) : baseType.getDefaultValue(); } @Override @@ -71,8 +71,8 @@ abstract class AbstractDerivedType> extends Abstract } @Override - public final String getUnits() { - return units != null ? units : baseType.getUnits(); + public final Optional getUnits() { + return units != null ? Optional.of(units) : baseType.getUnits(); } @Override diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/AbstractRestrictedType.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/AbstractRestrictedType.java index 89d5d129ad..3d94825691 100644 --- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/AbstractRestrictedType.java +++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/AbstractRestrictedType.java @@ -31,12 +31,12 @@ abstract class AbstractRestrictedType> extends Abstr } @Override - public final String getUnits() { + public final Optional getUnits() { return baseType.getUnits(); } @Override - public final Object getDefaultValue() { + public final Optional getDefaultValue() { return baseType.getDefaultValue(); } diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/ConcreteTypeBuilder.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/ConcreteTypeBuilder.java index e61d0f4a6c..3431f92a6f 100644 --- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/ConcreteTypeBuilder.java +++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/ConcreteTypeBuilder.java @@ -41,7 +41,8 @@ public abstract class ConcreteTypeBuilder> extends D @Override public final T build() { final T base = getBaseType(); - if (Objects.equals(getDefaultValue(), base.getDefaultValue()) && Objects.equals(getUnits(), base.getUnits())) { + if (Objects.equals(getDefaultValue(), base.getDefaultValue().orElse(null)) + && Objects.equals(getUnits(), base.getUnits().orElse(null))) { return base; } diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedTypeBuilder.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedTypeBuilder.java index e946992c84..943ede4403 100644 --- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedTypeBuilder.java +++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/DerivedTypeBuilder.java @@ -7,7 +7,10 @@ */ package org.opendaylight.yangtools.yang.model.util.type; -import com.google.common.base.Preconditions; +import static com.google.common.base.Preconditions.checkArgument; +import static java.util.Objects.requireNonNull; + +import java.util.Optional; import javax.annotation.Nonnull; import org.opendaylight.yangtools.yang.model.api.SchemaPath; import org.opendaylight.yangtools.yang.model.api.Status; @@ -29,38 +32,40 @@ public abstract class DerivedTypeBuilder> extends Ty private String units; DerivedTypeBuilder(final T baseType, final SchemaPath path) { - super(Preconditions.checkNotNull(baseType), path); + super(requireNonNull(baseType), path); - Preconditions.checkArgument(baseType instanceof AbstractBaseType - || baseType instanceof AbstractDerivedType || baseType instanceof AbstractRestrictedType, + checkArgument(baseType instanceof AbstractBaseType || baseType instanceof AbstractDerivedType + || baseType instanceof AbstractRestrictedType, "Derived type can be built only from a base, derived, or restricted type, not %s", baseType); // http://tools.ietf.org/html/rfc6020#section-7.3.4 - defaultValue = baseType.getDefaultValue(); + defaultValue = baseType.getDefaultValue().orElse(null); // In similar vein, it makes sense to propagate units - units = baseType.getUnits(); + units = baseType.getUnits().orElse(null); } public void setDefaultValue(@Nonnull final Object defaultValue) { - this.defaultValue = Preconditions.checkNotNull(defaultValue); + this.defaultValue = requireNonNull(defaultValue); } public final void setDescription(@Nonnull final String description) { - this.description = Preconditions.checkNotNull(description); + this.description = requireNonNull(description); } public final void setReference(@Nonnull final String reference) { - this.reference = Preconditions.checkNotNull(reference); + this.reference = requireNonNull(reference); } public final void setStatus(@Nonnull final Status status) { - this.status = Preconditions.checkNotNull(status); + this.status = requireNonNull(status); } public final void setUnits(final String units) { - Preconditions.checkNotNull(units); - if (getBaseType().getUnits() != null && !units.equals(getBaseType().getUnits())) { + requireNonNull(units); + + final Optional baseUnits = getBaseType().getUnits(); + if (baseUnits.isPresent() && !units.equals(baseUnits.get())) { LOG.warn("Type {} uverrides 'units' of type {} to \"{}\"", getPath(), getBaseType(), units); } diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/TypeDefinitions.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/TypeDefinitions.java index 44a4ed42e6..b3e261cf14 100644 --- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/TypeDefinitions.java +++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/type/TypeDefinitions.java @@ -32,8 +32,8 @@ final class TypeDefinitions { } private static int basicHashCode(final TypeDefinition type) { - return Objects.hash(type.getPath(), type.getUnknownSchemaNodes(), type.getBaseType(), type.getUnits(), - type.getDefaultValue()); + return Objects.hash(type.getPath(), type.getUnknownSchemaNodes(), type.getBaseType(), + type.getUnits().orElse(null), type.getDefaultValue().orElse(null)); } private static > T castIfEquals(final Class clazz, final T type, final Object obj) { @@ -52,22 +52,22 @@ final class TypeDefinitions { private static ToStringHelper toStringHelper(final TypeDefinition type) { return MoreObjects.toStringHelper(type).omitNullValues() .add("baseType", type.getBaseType()) - .add("default", type.getDefaultValue()) - .add("description", type.getDescription()) + .add("default", type.getDefaultValue().orElse(null)) + .add("description", type.getDescription().orElse(null)) .add("path", type.getPath()) - .add("reference", type.getReference()) + .add("reference", type.getReference().orElse(null)) .add("status", type.getStatus()) - .add("units", type.getUnits()); + .add("units", type.getUnits().orElse(null)); } static int hashCode(final BinaryTypeDefinition type) { - return Objects.hash(type.getPath(), type.getUnknownSchemaNodes(), type.getBaseType(), type.getUnits(), - type.getDefaultValue(), type.getLengthConstraint()); + return Objects.hash(type.getPath(), type.getUnknownSchemaNodes(), type.getBaseType(), + type.getUnits().orElse(null), type.getDefaultValue().orElse(null), type.getLengthConstraint().orElse(null)); } static int hashCode(final BitsTypeDefinition type) { - return Objects.hash(type.getPath(), type.getUnknownSchemaNodes(), type.getBaseType(), type.getUnits(), - type.getDefaultValue(), type.getBits()); + return Objects.hash(type.getPath(), type.getUnknownSchemaNodes(), type.getBaseType(), + type.getUnits().orElse(null), type.getDefaultValue().orElse(null), type.getBits()); } @@ -76,8 +76,9 @@ final class TypeDefinitions { } static int hashCode(final DecimalTypeDefinition type) { - return Objects.hash(type.getPath(), type.getUnknownSchemaNodes(), type.getBaseType(), type.getUnits(), - type.getDefaultValue(), type.getFractionDigits(), type.getRangeConstraints()); + return Objects.hash(type.getPath(), type.getUnknownSchemaNodes(), type.getBaseType(), + type.getUnits().orElse(null), type.getDefaultValue().orElse(null), type.getFractionDigits(), + type.getRangeConstraints()); } static int hashCode(final EmptyTypeDefinition type) { @@ -85,38 +86,40 @@ final class TypeDefinitions { } static int hashCode(final EnumTypeDefinition type) { - return Objects.hash(type.getPath(), type.getUnknownSchemaNodes(), type.getBaseType(), type.getUnits(), + return Objects.hash(type.getPath(), type.getUnknownSchemaNodes(), type.getBaseType(), + type.getUnits().orElse(null), type.getDefaultValue(), type.getValues()); } static int hashCode(final IdentityrefTypeDefinition type) { - return Objects.hash(type.getPath(), type.getUnknownSchemaNodes(), type.getBaseType(), type.getUnits(), - type.getDefaultValue(), type.getIdentity()); + return Objects.hash(type.getPath(), type.getUnknownSchemaNodes(), type.getBaseType(), + type.getUnits().orElse(null), type.getDefaultValue().orElse(null), type.getIdentities()); } static int hashCode(final InstanceIdentifierTypeDefinition type) { - return Objects.hash(type.getPath(), type.getUnknownSchemaNodes(), type.getBaseType(), type.getUnits(), - type.getDefaultValue(), type.requireInstance()); + return Objects.hash(type.getPath(), type.getUnknownSchemaNodes(), type.getBaseType(), + type.getUnits().orElse(null), type.getDefaultValue().orElse(null), type.requireInstance()); } static int hashCode(final IntegerTypeDefinition type) { - return Objects.hash(type.getPath(), type.getUnknownSchemaNodes(), type.getBaseType(), type.getUnits(), - type.getDefaultValue(), type.getRangeConstraints()); + return Objects.hash(type.getPath(), type.getUnknownSchemaNodes(), type.getBaseType(), + type.getUnits().orElse(null), type.getDefaultValue().orElse(null), type.getRangeConstraints()); } static int hashCode(final LeafrefTypeDefinition type) { - return Objects.hash(type.getPath(), type.getUnknownSchemaNodes(), type.getBaseType(), type.getUnits(), - type.getDefaultValue(), type.getPathStatement()); + return Objects.hash(type.getPath(), type.getUnknownSchemaNodes(), type.getBaseType(), + type.getUnits().orElse(null), type.getDefaultValue().orElse(null), type.getPathStatement()); } static int hashCode(final StringTypeDefinition type) { - return Objects.hash(type.getPath(), type.getUnknownSchemaNodes(), type.getBaseType(), type.getUnits(), - type.getDefaultValue(), type.getLengthConstraint(), type.getPatternConstraints()); + return Objects.hash(type.getPath(), type.getUnknownSchemaNodes(), type.getBaseType(), + type.getUnits().orElse(null), type.getDefaultValue().orElse(null), type.getLengthConstraint().orElse(null), + type.getPatternConstraints()); } static int hashCode(final UnionTypeDefinition type) { - return Objects.hash(type.getPath(), type.getUnknownSchemaNodes(), type.getBaseType(), type.getUnits(), - type.getDefaultValue(), type.getTypes()); + return Objects.hash(type.getPath(), type.getUnknownSchemaNodes(), type.getBaseType(), + type.getUnits().orElse(null), type.getDefaultValue().orElse(null), type.getTypes()); } static int hashCode(final UnsignedIntegerTypeDefinition type) { @@ -259,7 +262,7 @@ final class TypeDefinitions { } static String toString(final IdentityrefTypeDefinition type) { - return toStringHelper(type).add("identity", type.getIdentity()).toString(); + return toStringHelper(type).add("identities", type.getIdentities()).toString(); } static String toString(final InstanceIdentifierTypeDefinition type) { diff --git a/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/BinaryTypeTest.java b/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/BinaryTypeTest.java index db4e2dd475..8cf01ae3e3 100644 --- a/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/BinaryTypeTest.java +++ b/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/BinaryTypeTest.java @@ -9,11 +9,11 @@ package org.opendaylight.yangtools.yang.model.util; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; import static org.opendaylight.yangtools.yang.model.util.type.BaseTypes.binaryType; import java.util.Collections; +import java.util.Optional; import org.junit.Test; import org.opendaylight.yangtools.yang.model.api.Status; import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition; @@ -26,16 +26,15 @@ public class BinaryTypeTest { final BinaryTypeDefinition binType1 = binaryType(); assertFalse(binType.getLengthConstraint().isPresent()); - assertNull(binType.getDefaultValue()); + assertEquals(Optional.empty(), binType.getDefaultValue()); assertEquals("CURRENT", Status.CURRENT, binType.getStatus()); assertEquals("Base type is null", null, binType.getBaseType()); assertEquals("getQName gives BINARY_QNAME", BaseTypes.BINARY_QNAME, binType.getQName()); - assertNull("Units should be null", binType.getUnits()); - assertEquals("getPath gives List of BINARY_QNAME", - Collections.singletonList(BaseTypes.BINARY_QNAME), binType.getPath().getPathFromRoot()); + assertEquals(Optional.empty(), binType.getUnits()); + assertEquals("getPath gives List of BINARY_QNAME", Collections.singletonList(BaseTypes.BINARY_QNAME), + binType.getPath().getPathFromRoot()); - assertTrue("binType1 should equal to binType", - binType.equals(binType1) && binType1.equals(binType)); + assertTrue("binType1 should equal to binType", binType.equals(binType1) && binType1.equals(binType)); assertTrue("Hash code of binType and binType1 should be equal", binType.hashCode() == binType1.hashCode()); assertEquals("binType should equals to itself", binType, binType); diff --git a/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/BitsTypeTest.java b/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/BitsTypeTest.java index 399c24d7eb..ab965b29d1 100644 --- a/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/BitsTypeTest.java +++ b/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/BitsTypeTest.java @@ -14,6 +14,7 @@ import static org.junit.Assert.assertNull; import static org.mockito.Mockito.doReturn; import java.util.Collections; +import java.util.Optional; import org.junit.Test; import org.mockito.Mock; import org.mockito.MockitoAnnotations; @@ -40,11 +41,11 @@ public class BitsTypeTest { assertFalse(bitsType.getDescription().isPresent()); assertEquals("QName", qname, bitsType.getQName()); - assertNull("Should be null", bitsType.getUnits()); + assertEquals(Optional.empty(), bitsType.getUnits()); assertNotEquals("Description should not be null", null, bitsType.toString()); assertFalse(bitsType.getReference().isPresent()); assertNull("BaseType should be null", bitsType.getBaseType()); - assertNull("Default value should be null", bitsType.getDefaultValue()); + assertEquals(Optional.empty(), bitsType.getDefaultValue()); assertEquals("getPath should equal schemaPath", schemaPath, bitsType.getPath()); assertEquals("Status should be CURRENT", Status.CURRENT, bitsType.getStatus()); assertEquals("Should be empty list", Collections.EMPTY_LIST, bitsType.getUnknownSchemaNodes()); diff --git a/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/BooleanTypeTest.java b/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/BooleanTypeTest.java index 7c32cdfe16..e992850efb 100644 --- a/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/BooleanTypeTest.java +++ b/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/BooleanTypeTest.java @@ -9,11 +9,11 @@ package org.opendaylight.yangtools.yang.model.util; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; import static org.opendaylight.yangtools.yang.model.util.type.BaseTypes.booleanType; import java.util.Collections; +import java.util.Optional; import org.junit.Test; import org.opendaylight.yangtools.yang.model.api.Status; import org.opendaylight.yangtools.yang.model.api.type.BooleanTypeDefinition; @@ -32,9 +32,9 @@ public class BooleanTypeTest { final String strPath = boolType.getPath().toString(); assertTrue("Should contain string of getPath", stringBoolType.contains(strPath)); - assertNull("Should be null", boolType.getUnits()); + assertEquals(Optional.empty(), boolType.getUnits()); assertEquals("Base type is null", null, boolType.getBaseType()); - assertNull("Default value is null", boolType.getDefaultValue()); + assertEquals(Optional.empty(), boolType.getDefaultValue()); assertEquals("Status CURRENT", Status.CURRENT, boolType.getStatus()); assertEquals("Should contain empty list", Collections.EMPTY_LIST, boolType.getUnknownSchemaNodes()); } diff --git a/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/EmptyTypeTest.java b/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/EmptyTypeTest.java index cb2ec8777a..8b16d754ce 100644 --- a/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/EmptyTypeTest.java +++ b/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/EmptyTypeTest.java @@ -13,6 +13,7 @@ import static org.junit.Assert.assertTrue; import static org.opendaylight.yangtools.yang.model.util.type.BaseTypes.emptyType; import java.util.Collections; +import java.util.Optional; import org.junit.Test; import org.opendaylight.yangtools.yang.model.api.Status; import org.opendaylight.yangtools.yang.model.api.type.EmptyTypeDefinition; @@ -27,10 +28,10 @@ public class EmptyTypeTest { assertEquals("Path", Collections.singletonList(BaseTypes.EMPTY_QNAME), emptyType.getPath().getPathFromRoot()); assertEquals("BaseType", null, emptyType.getBaseType()); - assertEquals("DefaultValue", null, emptyType.getDefaultValue()); + assertEquals("DefaultValue", Optional.empty(), emptyType.getDefaultValue()); assertEquals("Status", Status.CURRENT, emptyType.getStatus()); assertFalse(emptyType.getReference().isPresent()); - assertEquals("Units", null, emptyType.getUnits()); + assertEquals("Units", Optional.empty(), emptyType.getUnits()); assertFalse(emptyType.getDescription().isPresent()); assertEquals("UnknownSchemaNodes", Collections.EMPTY_LIST, emptyType.getUnknownSchemaNodes()); assertTrue("toString", emptyType.toString().contains("empty")); diff --git a/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/Int8Test.java b/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/Int8Test.java index 5bf00d6018..9387c7827c 100644 --- a/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/Int8Test.java +++ b/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/Int8Test.java @@ -7,8 +7,11 @@ */ package org.opendaylight.yangtools.yang.model.util; -import static org.junit.Assert.assertTrue; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertSame; +import java.util.Optional; import org.junit.Test; import org.opendaylight.yangtools.yang.model.api.type.IntegerTypeDefinition; import org.opendaylight.yangtools.yang.model.util.type.BaseTypes; @@ -19,8 +22,9 @@ public class Int8Test { public void testInt8() { IntegerTypeDefinition int8 = BaseTypes.int8Type(); IntegerTypeDefinition int8Second = BaseTypes.int8Type(); - assertTrue("The method 'getInstance()' has to return the same instance", int8 == int8Second); - assertTrue("The method 'getBaseType()' is returning incorrect value", int8.getBaseType() == null); - assertTrue("The method 'getDefaultType()' is returning incorrect value", int8.getDefaultValue() == null); + assertSame("The method 'getInstance()' has to return the same instance", int8, int8Second); + assertNull("The method 'getBaseType()' is returning incorrect value", int8.getBaseType()); + assertEquals("The method 'getDefaultType()' is returning incorrect value", Optional.empty(), + int8.getDefaultValue()); } } diff --git a/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/LeafrefTest.java b/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/LeafrefTest.java index f3d8d25889..19d4c00f42 100644 --- a/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/LeafrefTest.java +++ b/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/LeafrefTest.java @@ -15,6 +15,7 @@ import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; +import java.util.Optional; import org.junit.Test; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.model.api.SchemaPath; @@ -42,8 +43,8 @@ public class LeafrefTest { assertNotNull("Object 'leafref' shouldn't be null.", leafref); assertNull("Base type of 'leafref' should be null.", leafref.getBaseType()); - assertNull("Units of 'leafref' should be empty.", leafref.getUnits()); - assertNull("Leafref does not have a default value", leafref.getDefaultValue()); + assertEquals(Optional.empty(), leafref.getUnits()); + assertEquals(Optional.empty(), leafref.getDefaultValue()); assertEquals(QName.create("test", "List1"), leafref.getQName()); assertEquals("SchemaPath of 'leafref' is '/Cont1/List1'.", schemaPath, leafref.getPath()); assertFalse(leafref.getDescription().isPresent()); diff --git a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/DeviationResolutionTest.java b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/DeviationResolutionTest.java index bafaf7df9b..56bdd32872 100644 --- a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/DeviationResolutionTest.java +++ b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/DeviationResolutionTest.java @@ -18,6 +18,7 @@ import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResour import java.io.ByteArrayOutputStream; import java.io.PrintStream; +import java.util.Optional; import org.junit.Test; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.common.Revision; @@ -124,8 +125,8 @@ public class DeviationResolutionTest { assertNotNull(myLeaf); assertTrue(myLeaf.getType() instanceof UnsignedIntegerTypeDefinition); - assertEquals("bytes", myLeaf.getType().getUnits()); - assertEquals("10", myLeaf.getType().getDefaultValue()); + assertEquals(Optional.of("bytes"), myLeaf.getType().getUnits()); + assertEquals(Optional.of("10"), myLeaf.getType().getDefaultValue()); final LeafListSchemaNode myLeafList = (LeafListSchemaNode) barModule.getDataChildByName( QName.create(barModule.getQNameModule(), "my-leaf-list-test")); @@ -151,8 +152,8 @@ public class DeviationResolutionTest { QName.create(barModule.getQNameModule(), "my-aug-leaf")); assertNotNull(myAugLeaf); assertTrue(myAugLeaf.getType() instanceof UnsignedIntegerTypeDefinition); - assertEquals("seconds", myAugLeaf.getType().getUnits()); - assertEquals("new-def-val", myAugLeaf.getType().getDefaultValue()); + assertEquals(Optional.of("seconds"), myAugLeaf.getType().getUnits()); + assertEquals(Optional.of("new-def-val"), myAugLeaf.getType().getDefaultValue()); assertEquals(1, myAugLeaf.getUnknownSchemaNodes().size()); assertEquals("new arg", myAugLeaf.getUnknownSchemaNodes().iterator().next().getNodeParameter()); @@ -160,8 +161,8 @@ public class DeviationResolutionTest { QName.create(barModule.getQNameModule(), "my-used-leaf")); assertNotNull(myUsedLeaf); assertTrue(myUsedLeaf.getType() instanceof UnsignedIntegerTypeDefinition); - assertEquals("weeks", myUsedLeaf.getType().getUnits()); - assertEquals("new-def-val", myUsedLeaf.getType().getDefaultValue()); + assertEquals(Optional.of("weeks"), myUsedLeaf.getType().getUnits()); + assertEquals(Optional.of("new-def-val"), myUsedLeaf.getType().getDefaultValue()); assertEquals(1, myUsedLeaf.getUnknownSchemaNodes().size()); assertEquals("new arg", myUsedLeaf.getUnknownSchemaNodes().iterator().next().getNodeParameter()); } @@ -178,8 +179,8 @@ public class DeviationResolutionTest { QName.create(barModule.getQNameModule(), "my-leaf")); assertNotNull(myLeaf); - assertNull(myLeaf.getType().getDefaultValue()); - assertNull(myLeaf.getType().getUnits()); + assertEquals(Optional.empty(), myLeaf.getType().getDefaultValue()); + assertEquals(Optional.empty(), myLeaf.getType().getUnits()); assertEquals(0, myLeaf.getUnknownSchemaNodes().size()); final LeafListSchemaNode myLeafList = (LeafListSchemaNode) barModule.getDataChildByName( @@ -203,16 +204,16 @@ public class DeviationResolutionTest { final LeafSchemaNode myAugLeaf = (LeafSchemaNode) myCont.getDataChildByName( QName.create(barModule.getQNameModule(), "my-aug-leaf")); assertNotNull(myAugLeaf); - assertNull(myAugLeaf.getType().getDefaultValue()); - assertNull(myAugLeaf.getType().getUnits()); + assertEquals(Optional.empty(), myAugLeaf.getType().getDefaultValue()); + assertEquals(Optional.empty(), myAugLeaf.getType().getUnits()); assertEquals(0, myAugLeaf.getConstraints().getMustConstraints().size()); assertEquals(0, myAugLeaf.getUnknownSchemaNodes().size()); final LeafSchemaNode myUsedLeaf = (LeafSchemaNode) myCont.getDataChildByName( QName.create(barModule.getQNameModule(), "my-used-leaf")); assertNotNull(myUsedLeaf); - assertNull(myUsedLeaf.getType().getDefaultValue()); - assertNull(myUsedLeaf.getType().getUnits()); + assertEquals(Optional.empty(), myUsedLeaf.getType().getDefaultValue()); + assertEquals(Optional.empty(), myUsedLeaf.getType().getUnits()); assertEquals(0, myUsedLeaf.getConstraints().getMustConstraints().size()); assertEquals(0, myUsedLeaf.getUnknownSchemaNodes().size()); } diff --git a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/EffectiveStatementTypeTest.java b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/EffectiveStatementTypeTest.java index 78d098ecc5..a034199671 100644 --- a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/EffectiveStatementTypeTest.java +++ b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/EffectiveStatementTypeTest.java @@ -80,8 +80,8 @@ public class EffectiveStatementTypeTest { .effectiveSubstatements().iterator().next()).getTypeDefinition(); assertNull(binaryEff.getBaseType()); - assertNull(binaryEff.getUnits()); - assertNull(binaryEff.getDefaultValue()); + assertEquals(Optional.empty(), binaryEff.getUnits()); + assertEquals(Optional.empty(), binaryEff.getDefaultValue()); assertEquals("binary", binaryEff.getQName().getLocalName()); assertFalse(binaryEff.getLengthConstraint().isPresent()); assertEquals(Status.CURRENT, binaryEff.getStatus()); @@ -112,14 +112,14 @@ public class EffectiveStatementTypeTest { assertFalse(bitsEff.getDescription().isPresent()); assertFalse(bitsEff.getReference().isPresent()); assertEquals(Status.CURRENT, bitsEff.getStatus()); - assertNull(bitsEff.getUnits()); + assertEquals(Optional.empty(), bitsEff.getUnits()); assertNotNull(bitsEff.toString()); assertNotNull(bitsEff.hashCode()); assertFalse(bitsEff.equals(null)); assertFalse(bitsEff.equals("test")); assertTrue(bitsEff.equals(bitsEff)); assertEquals(3, bitsEff.getBits().size()); - assertNull(bitsEff.getDefaultValue()); + assertEquals(Optional.empty(), bitsEff.getDefaultValue()); assertNotNull(bitEff.getPath()); assertNotNull(bitEff.getUnknownSchemaNodes()); @@ -145,8 +145,8 @@ public class EffectiveStatementTypeTest { .getTypeDefinition(); assertNull(booleanEff.getBaseType()); - assertNull(booleanEff.getUnits()); - assertNull(booleanEff.getDefaultValue()); + assertEquals(Optional.empty(), booleanEff.getUnits()); + assertEquals(Optional.empty(), booleanEff.getDefaultValue()); assertEquals("boolean", booleanEff.getQName().getLocalName()); assertNull(booleanEff.getPath().getParent().getParent()); assertNotNull(booleanEff.getUnknownSchemaNodes()); @@ -165,8 +165,8 @@ public class EffectiveStatementTypeTest { .getTypeDefinition(); assertNull(decimal64Eff.getBaseType()); - assertNull(decimal64Eff.getUnits()); - assertNull(decimal64Eff.getDefaultValue()); + assertEquals(Optional.empty(), decimal64Eff.getUnits()); + assertEquals(Optional.empty(), decimal64Eff.getDefaultValue()); assertEquals("decimal64", decimal64Eff.getQName().getLocalName()); assertNotNull(decimal64Eff.getUnknownSchemaNodes()); @@ -195,8 +195,8 @@ public class EffectiveStatementTypeTest { ((LeafEffectiveStatementImpl) currentLeaf).effectiveSubstatements().iterator().next()) .getTypeDefinition(); - assertNull(emptyEff.getUnits()); - assertNull(emptyEff.getDefaultValue()); + assertEquals(Optional.empty(), emptyEff.getUnits()); + assertEquals(Optional.empty(), emptyEff.getDefaultValue()); assertNull(emptyEff.getBaseType()); assertEquals("empty", emptyEff.getQName().getLocalName()); assertNull(emptyEff.getPath().getParent().getParent()); @@ -220,14 +220,14 @@ public class EffectiveStatementTypeTest { assertEquals("enumeration", enumSpecEff.getQName().getLocalName()); assertEquals("enumeration", enumSpecEff.getPath().getLastComponent().getLocalName()); - assertNull(enumSpecEff.getDefaultValue()); + assertEquals(Optional.empty(), enumSpecEff.getDefaultValue()); assertEquals(3, enumSpecEff.getValues().size()); assertNull(enumSpecEff.getBaseType()); assertNotNull(enumSpecEff.getUnknownSchemaNodes()); assertEquals(Status.CURRENT, enumSpecEff.getStatus()); assertFalse(enumSpecEff.getDescription().isPresent()); assertFalse(enumSpecEff.getReference().isPresent()); - assertNull(enumSpecEff.getUnits()); + assertEquals(Optional.empty(), enumSpecEff.getUnits()); assertNotNull(enumSpecEff.toString()); assertNotNull(enumSpecEff.hashCode()); assertFalse(enumSpecEff.equals(null)); @@ -251,7 +251,7 @@ public class EffectiveStatementTypeTest { ((LeafEffectiveStatementImpl) currentLeaf).effectiveSubstatements().iterator().next()) .getTypeDefinition(); - assertNull(identityRefEff.getDefaultValue()); + assertEquals(Optional.empty(), identityRefEff.getDefaultValue()); assertEquals("identityref", identityRefEff.getQName().getLocalName()); assertEquals("identityref", identityRefEff.getPath().getLastComponent().getLocalName()); assertNull(identityRefEff.getBaseType()); @@ -263,7 +263,7 @@ public class EffectiveStatementTypeTest { assertNotNull(identityRefEff.toString()); // FIXME: the model is wrong, but we accept units in 'type' statement - assertNull(identityRefEff.getUnits()); + assertEquals(Optional.empty(), identityRefEff.getUnits()); } @Test @@ -280,11 +280,11 @@ public class EffectiveStatementTypeTest { assertEquals("instance-identifier", instanceIdentEff.getQName().getLocalName()); assertEquals("instance-identifier", instanceIdentEff.getPath().getLastComponent().getLocalName()); assertNull(instanceIdentEff.getBaseType()); - assertNull(instanceIdentEff.getDefaultValue()); + assertEquals(Optional.empty(), instanceIdentEff.getDefaultValue()); assertNotNull(instanceIdentEff.getUnknownSchemaNodes()); assertFalse(instanceIdentEff.getDescription().isPresent()); assertFalse(instanceIdentEff.getReference().isPresent()); - assertNull(instanceIdentEff.getUnits()); + assertEquals(Optional.empty(), instanceIdentEff.getUnits()); assertEquals(Status.CURRENT, instanceIdentEff.getStatus()); assertNotNull(instanceIdentEff.hashCode()); assertFalse(instanceIdentEff.equals(null)); @@ -303,8 +303,8 @@ public class EffectiveStatementTypeTest { assertEquals("/container-test/leaf-test", leafrefEff.getPathStatement().toString()); assertNull(leafrefEff.getBaseType()); - assertNull(leafrefEff.getUnits()); - assertNull(leafrefEff.getDefaultValue()); + assertEquals(Optional.empty(), leafrefEff.getUnits()); + assertEquals(Optional.empty(), leafrefEff.getDefaultValue()); assertNotNull(leafrefEff.toString()); assertEquals("leafref", leafrefEff.getQName().getLocalName()); assertEquals(Status.CURRENT, leafrefEff.getStatus()); @@ -382,8 +382,8 @@ public class EffectiveStatementTypeTest { assertEquals("CURRENT", unionEff.getStatus().toString()); assertNotNull(unionEff.getUnknownSchemaNodes()); assertNull(unionEff.getBaseType()); - assertNull(unionEff.getUnits()); - assertNull(unionEff.getDefaultValue()); + assertEquals(Optional.empty(), unionEff.getUnits()); + assertEquals(Optional.empty(), unionEff.getDefaultValue()); assertFalse(unionEff.getDescription().isPresent()); assertFalse(unionEff.getReference().isPresent()); assertNotNull(unionEff.toString()); @@ -462,8 +462,8 @@ public class EffectiveStatementTypeTest { assertEquals("string", stringEff.getQName().getLocalName()); assertEquals(Status.CURRENT, stringEff.getStatus()); - assertNull(stringEff.getUnits()); - assertNull(stringEff.getDefaultValue()); + assertEquals(Optional.empty(), stringEff.getUnits()); + assertEquals(Optional.empty(), stringEff.getDefaultValue()); assertNotNull(stringEff.getUnknownSchemaNodes()); assertNull(stringEff.getBaseType()); assertFalse(stringEff.getDescription().isPresent()); diff --git a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/GroupingTest.java b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/GroupingTest.java index c03f6aaed2..8e1ec849de 100644 --- a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/GroupingTest.java +++ b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/GroupingTest.java @@ -192,7 +192,7 @@ public class GroupingTest { final LeafSchemaNode address_u = (LeafSchemaNode) destination.getDataChildByName(QName.create( foo.getQNameModule(), "address")); assertNotNull(address_u); - assertEquals("1.2.3.4", address_u.getType().getDefaultValue()); + assertEquals(Optional.of("1.2.3.4"), address_u.getType().getDefaultValue()); assertEquals(Optional.of("IP address of target node"), address_u.getDescription()); assertEquals(Optional.of("address reference added by refine"), address_u.getReference()); assertFalse(address_u.isConfiguration()); @@ -203,7 +203,7 @@ public class GroupingTest { baz.getQNameModule(), "address")); assertNotNull(address_g); assertFalse(address_g.isAddedByUses()); - assertNull(address_g.getType().getDefaultValue()); + assertEquals(Optional.empty(), address_g.getType().getDefaultValue()); assertEquals(Optional.of("Target IP address"), address_g.getDescription()); assertFalse(address_g.getReference().isPresent()); assertTrue(address_g.isConfiguration()); @@ -313,7 +313,7 @@ public class GroupingTest { final LeafSchemaNode address_u = (LeafSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(), "address")); assertNotNull(address_u); - assertNull(address_u.getType().getDefaultValue()); + assertEquals(Optional.empty(), address_u.getType().getDefaultValue()); assertEquals(Optional.of("Target IP address"), address_u.getDescription()); assertFalse(address_u.getReference().isPresent()); assertTrue(address_u.isConfiguration()); @@ -323,7 +323,7 @@ public class GroupingTest { baz.getQNameModule(), "address")); assertNotNull(address_g); assertFalse(address_g.isAddedByUses()); - assertNull(address_g.getType().getDefaultValue()); + assertEquals(Optional.empty(), address_g.getType().getDefaultValue()); assertEquals(Optional.of("Target IP address"), address_g.getDescription()); assertFalse(address_g.getReference().isPresent()); assertTrue(address_g.isConfiguration()); diff --git a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/ListTest.java b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/ListTest.java index 72b5531be5..ff7e6bc044 100644 --- a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/ListTest.java +++ b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/ListTest.java @@ -15,6 +15,7 @@ import static org.junit.Assert.assertTrue; import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource; import java.util.List; +import java.util.Optional; import org.junit.Test; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode; @@ -79,7 +80,7 @@ public class ListTest { assertNotNull(leaf); assertFalse(leaf.getConstraints().isMandatory()); assertEquals("young-leaf", leaf.getType().getQName().getLocalName()); - assertEquals("default-value", leaf.getType().getDefaultValue()); + assertEquals(Optional.of("default-value"), leaf.getType().getDefaultValue()); final LeafListSchemaNode leafList = (LeafListSchemaNode) list.getDataChildByName( QName.create(testModule.getQNameModule(), "list-of-leaves")); diff --git a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/TypedefSubStmtsTest.java b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/TypedefSubStmtsTest.java index 8cd5caebf4..b5959a2ba0 100644 --- a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/TypedefSubStmtsTest.java +++ b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/TypedefSubStmtsTest.java @@ -12,6 +12,7 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource; +import java.util.Optional; import java.util.Set; import org.junit.Test; import org.opendaylight.yangtools.yang.model.api.SchemaContext; @@ -40,7 +41,7 @@ public class TypedefSubStmtsTest { TypeDefinition typedef = typedefs.iterator().next(); assertEquals("time-of-the-day", typedef.getQName().getLocalName()); assertEquals("string", typedef.getBaseType().getQName().getLocalName()); - assertEquals("24-hour-clock", typedef.getUnits()); - assertEquals("1am", typedef.getDefaultValue().toString()); + assertEquals(Optional.of("24-hour-clock"), typedef.getUnits()); + assertEquals("1am", typedef.getDefaultValue().map(Object::toString).orElse(null)); } } diff --git a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/YangParserTest.java b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/YangParserTest.java index a17845e518..62616523e1 100644 --- a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/YangParserTest.java +++ b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/YangParserTest.java @@ -160,7 +160,7 @@ public class YangParserTest { "ifIndex")); assertEquals(ifEntry.getKeyDefinition().get(0), ifIndex.getQName()); assertTrue(ifIndex.getType() instanceof UnsignedIntegerTypeDefinition); - assertEquals("minutes", ifIndex.getType().getUnits()); + assertEquals(Optional.of("minutes"), ifIndex.getType().getUnits()); final LeafSchemaNode ifMtu = (LeafSchemaNode) ifEntry.getDataChildByName(QName.create(bar.getQNameModule(), "ifMtu")); assertEquals(BaseTypes.int32Type(), ifMtu.getType()); @@ -173,8 +173,8 @@ public class YangParserTest { final IntegerTypeDefinition leafType = (IntegerTypeDefinition) int32Leaf.getType(); assertEquals(QName.create(FOO, "int32-ext2"), leafType.getQName()); - assertEquals("mile", leafType.getUnits()); - assertEquals("11", leafType.getDefaultValue()); + assertEquals(Optional.of("mile"), leafType.getUnits()); + assertEquals(Optional.of("11"), leafType.getDefaultValue()); final List ranges = leafType.getRangeConstraints(); assertEquals(1, ranges.size()); @@ -184,8 +184,8 @@ public class YangParserTest { final IntegerTypeDefinition baseType = leafType.getBaseType(); assertEquals(QName.create(BAR, "int32-ext2"), baseType.getQName()); - assertEquals("mile", baseType.getUnits()); - assertEquals("11", baseType.getDefaultValue()); + assertEquals(Optional.of("mile"), baseType.getUnits()); + assertEquals(Optional.of("11"), baseType.getDefaultValue()); final List baseTypeRanges = baseType.getRangeConstraints(); assertEquals(2, baseTypeRanges.size()); @@ -200,8 +200,8 @@ public class YangParserTest { final QName baseQName = base.getQName(); assertEquals("int32-ext1", baseQName.getLocalName()); assertEquals(BAR, baseQName.getModule()); - assertNull(base.getUnits()); - assertNull(base.getDefaultValue()); + assertEquals(Optional.empty(), base.getUnits()); + assertEquals(Optional.empty(), base.getDefaultValue()); final List baseRanges = base.getRangeConstraints(); assertEquals(1, baseRanges.size()); @@ -222,8 +222,8 @@ public class YangParserTest { final QName typeQName = type.getQName(); assertEquals("string-ext4", typeQName.getLocalName()); assertEquals(BAR, typeQName.getModule()); - assertNull(type.getUnits()); - assertNull(type.getDefaultValue()); + assertEquals(Optional.empty(), type.getUnits()); + assertEquals(Optional.empty(), type.getDefaultValue()); List patterns = type.getPatternConstraints(); assertEquals(1, patterns.size()); PatternConstraint pattern = patterns.iterator().next(); @@ -234,8 +234,8 @@ public class YangParserTest { final QName baseType1QName = baseType1.getQName(); assertEquals("string-ext3", baseType1QName.getLocalName()); assertEquals(BAR, baseType1QName.getModule()); - assertNull(baseType1.getUnits()); - assertNull(baseType1.getDefaultValue()); + assertEquals(Optional.empty(), baseType1.getUnits()); + assertEquals(Optional.empty(), baseType1.getDefaultValue()); patterns = baseType1.getPatternConstraints(); assertEquals(1, patterns.size()); pattern = patterns.iterator().next(); @@ -246,8 +246,8 @@ public class YangParserTest { final QName baseType2QName = baseType2.getQName(); assertEquals("string-ext2", baseType2QName.getLocalName()); assertEquals(BAR, baseType2QName.getModule()); - assertNull(baseType2.getUnits()); - assertNull(baseType2.getDefaultValue()); + assertEquals(Optional.empty(), baseType2.getUnits()); + assertEquals(Optional.empty(), baseType2.getDefaultValue()); assertTrue(baseType2.getPatternConstraints().isEmpty()); final RangeSet baseType2Lengths = baseType2.getLengthConstraint().get().getAllowedRanges(); assertEquals(1, baseType2Lengths.asRanges().size()); @@ -257,8 +257,8 @@ public class YangParserTest { final StringTypeDefinition baseType3 = baseType2.getBaseType(); assertEquals(QName.create(BAR, "string-ext1"), baseType3.getQName()); - assertNull(baseType3.getUnits()); - assertNull(baseType3.getDefaultValue()); + assertEquals(Optional.empty(), baseType3.getUnits()); + assertEquals(Optional.empty(), baseType3.getDefaultValue()); patterns = baseType3.getPatternConstraints(); assertEquals(1, patterns.size()); pattern = patterns.iterator().next(); @@ -278,8 +278,8 @@ public class YangParserTest { .getDataChildByName(QName.create(foo.getQNameModule(), "invalid-pattern-string-leaf")); StringTypeDefinition type = (StringTypeDefinition) invalidPatternStringLeaf.getType(); assertEquals(QName.create(BAR, "invalid-string-pattern"), type.getQName()); - assertNull(type.getUnits()); - assertNull(type.getDefaultValue()); + assertEquals(Optional.empty(), type.getUnits()); + assertEquals(Optional.empty(), type.getDefaultValue()); List patterns = type.getPatternConstraints(); assertTrue(patterns.isEmpty()); @@ -288,8 +288,8 @@ public class YangParserTest { type = (StringTypeDefinition) invalidDirectStringPatternDefLeaf.getType(); assertEquals(QName.create(YangConstants.RFC6020_YANG_MODULE, "string"), type.getQName()); - assertNull(type.getUnits()); - assertNull(type.getDefaultValue()); + assertEquals(Optional.empty(), type.getUnits()); + assertEquals(Optional.empty(), type.getDefaultValue()); patterns = type.getPatternConstraints(); assertTrue(patterns.isEmpty()); @@ -297,8 +297,8 @@ public class YangParserTest { .getDataChildByName(QName.create(foo.getQNameModule(), "multiple-pattern-string-leaf")); type = (StringTypeDefinition) multiplePatternStringLeaf.getType(); assertEquals(QName.create(BAR, "multiple-pattern-string"), type.getQName()); - assertNull(type.getUnits()); - assertNull(type.getDefaultValue()); + assertEquals(Optional.empty(), type.getUnits()); + assertEquals(Optional.empty(), type.getDefaultValue()); patterns = type.getPatternConstraints(); assertTrue(!patterns.isEmpty()); assertEquals(1, patterns.size()); @@ -310,8 +310,8 @@ public class YangParserTest { .getDataChildByName(QName.create(foo.getQNameModule(), "multiple-pattern-direct-string-def-leaf")); type = (StringTypeDefinition) multiplePatternDirectStringDefLeaf.getType(); assertEquals(QName.create(FOO, "string"), type.getQName()); - assertNull(type.getUnits()); - assertNull(type.getDefaultValue()); + assertEquals(Optional.empty(), type.getUnits()); + assertEquals(Optional.empty(), type.getDefaultValue()); patterns = type.getPatternConstraints(); assertTrue(!patterns.isEmpty()); assertEquals(2, patterns.size()); @@ -336,8 +336,8 @@ public class YangParserTest { final StringTypeDefinition type = (StringTypeDefinition) lengthLeaf.getType(); assertEquals(QName.create(FOO, "string-ext2"), type.getQName()); - assertNull(type.getUnits()); - assertNull(type.getDefaultValue()); + assertEquals(Optional.empty(), type.getUnits()); + assertEquals(Optional.empty(), type.getDefaultValue()); assertTrue(type.getPatternConstraints().isEmpty()); final RangeSet typeLengths = type.getLengthConstraint().get().getAllowedRanges(); assertEquals(1, typeLengths.asRanges().size()); @@ -347,8 +347,8 @@ public class YangParserTest { final StringTypeDefinition baseType1 = type.getBaseType(); assertEquals(QName.create(BAR, "string-ext2"), baseType1.getQName()); - assertNull(baseType1.getUnits()); - assertNull(baseType1.getDefaultValue()); + assertEquals(Optional.empty(), baseType1.getUnits()); + assertEquals(Optional.empty(), baseType1.getDefaultValue()); assertTrue(baseType1.getPatternConstraints().isEmpty()); final RangeSet baseType2Lengths = baseType1.getLengthConstraint().get().getAllowedRanges(); assertEquals(1, baseType2Lengths.asRanges().size()); @@ -358,8 +358,8 @@ public class YangParserTest { final StringTypeDefinition baseType2 = baseType1.getBaseType(); assertEquals(QName.create(BAR, "string-ext1"), baseType2.getQName()); - assertNull(baseType2.getUnits()); - assertNull(baseType2.getDefaultValue()); + assertEquals(Optional.empty(), baseType2.getUnits()); + assertEquals(Optional.empty(), baseType2.getDefaultValue()); final List patterns = baseType2.getPatternConstraints(); assertEquals(1, patterns.size()); final PatternConstraint pattern = patterns.iterator().next(); @@ -381,15 +381,15 @@ public class YangParserTest { assertTrue(testleaf.getType() instanceof DecimalTypeDefinition); final DecimalTypeDefinition type = (DecimalTypeDefinition) testleaf.getType(); assertEquals(QName.create(BAR, "my-decimal-type"), type.getQName()); - assertNull(type.getUnits()); - assertNull(type.getDefaultValue()); + assertEquals(Optional.empty(), type.getUnits()); + assertEquals(Optional.empty(), type.getDefaultValue()); assertEquals(6, type.getFractionDigits().intValue()); assertEquals(1, type.getRangeConstraints().size()); final DecimalTypeDefinition typeBase = type.getBaseType(); assertEquals(QName.create(BAR, "decimal64"), typeBase.getQName()); - assertNull(typeBase.getUnits()); - assertNull(typeBase.getDefaultValue()); + assertEquals(Optional.empty(), typeBase.getUnits()); + assertEquals(Optional.empty(), typeBase.getDefaultValue()); assertEquals(6, typeBase.getFractionDigits().intValue()); assertEquals(1, typeBase.getRangeConstraints().size()); @@ -404,8 +404,8 @@ public class YangParserTest { assertTrue(testleaf.getType() instanceof DecimalTypeDefinition); final DecimalTypeDefinition type = (DecimalTypeDefinition) testleaf.getType(); assertEquals(QName.create(BAR, "my-decimal-type"), type.getQName()); - assertNull(type.getUnits()); - assertNull(type.getDefaultValue()); + assertEquals(Optional.empty(), type.getUnits()); + assertEquals(Optional.empty(), type.getDefaultValue()); assertEquals(6, type.getFractionDigits().intValue()); assertEquals(1, type.getRangeConstraints().size()); @@ -421,13 +421,13 @@ public class YangParserTest { assertTrue(unionleaf.getType() instanceof UnionTypeDefinition); final UnionTypeDefinition type = (UnionTypeDefinition) unionleaf.getType(); assertEquals(QName.create(BAR, "my-union-ext"), type.getQName()); - assertNull(type.getUnits()); - assertNull(type.getDefaultValue()); + assertEquals(Optional.empty(), type.getUnits()); + assertEquals(Optional.empty(), type.getDefaultValue()); final UnionTypeDefinition baseType = type.getBaseType(); assertEquals(QName.create(BAR, "my-union"), baseType.getQName()); - assertNull(baseType.getUnits()); - assertNull(baseType.getDefaultValue()); + assertEquals(Optional.empty(), baseType.getUnits()); + assertEquals(Optional.empty(), baseType.getDefaultValue()); final UnionTypeDefinition unionType = baseType.getBaseType(); final List> unionTypes = unionType.getTypes(); @@ -435,8 +435,8 @@ public class YangParserTest { final IntegerTypeDefinition unionType1 = (IntegerTypeDefinition) unionTypes.get(0); assertEquals(QName.create(BAR, "my-union"), baseType.getQName()); - assertNull(unionType1.getUnits()); - assertNull(unionType1.getDefaultValue()); + assertEquals(Optional.empty(), unionType1.getUnits()); + assertEquals(Optional.empty(), unionType1.getDefaultValue()); final List ranges = unionType1.getRangeConstraints(); assertEquals(1, ranges.size()); @@ -456,13 +456,13 @@ public class YangParserTest { assertTrue(testleaf.getType() instanceof UnionTypeDefinition); final UnionTypeDefinition type = (UnionTypeDefinition) testleaf.getType(); assertEquals(QName.create(BAZ, "union1"), type.getQName()); - assertNull(type.getUnits()); - assertNull(type.getDefaultValue()); + assertEquals(Optional.empty(), type.getUnits()); + assertEquals(Optional.empty(), type.getDefaultValue()); final UnionTypeDefinition typeBase = type.getBaseType(); assertEquals(QName.create(BAZ, "union2"), typeBase.getQName()); - assertNull(typeBase.getUnits()); - assertNull(typeBase.getDefaultValue()); + assertEquals(Optional.empty(), typeBase.getUnits()); + assertEquals(Optional.empty(), typeBase.getDefaultValue()); final UnionTypeDefinition union = typeBase.getBaseType(); final List> unionTypes = union.getTypes(); @@ -472,8 +472,8 @@ public class YangParserTest { final UnionTypeDefinition unionType1 = (UnionTypeDefinition) unionTypes.get(1); assertEquals(QName.create(BAR, "nested-union2"), unionType1.getQName()); - assertNull(unionType1.getUnits()); - assertNull(unionType1.getDefaultValue()); + assertEquals(Optional.empty(), unionType1.getUnits()); + assertEquals(Optional.empty(), unionType1.getDefaultValue()); final UnionTypeDefinition nestedUnion = unionType1.getBaseType(); final List> nestedUnion2Types = nestedUnion.getTypes(); @@ -483,14 +483,14 @@ public class YangParserTest { final UnionTypeDefinition myUnionExt = (UnionTypeDefinition) nestedUnion2Types.get(0); assertEquals(QName.create(BAR, "my-union-ext"), myUnionExt.getQName()); - assertNull(myUnionExt.getUnits()); - assertNull(myUnionExt.getDefaultValue()); + assertEquals(Optional.empty(), myUnionExt.getUnits()); + assertEquals(Optional.empty(), myUnionExt.getDefaultValue()); final UnionTypeDefinition myUnion = myUnionExt.getBaseType(); assertEquals(QName.create(BAR, "my-union"), myUnion.getQName()); - assertNull(myUnion.getUnits()); - assertNull(myUnion.getDefaultValue()); + assertEquals(Optional.empty(), myUnion.getUnits()); + assertEquals(Optional.empty(), myUnion.getDefaultValue()); final UnionTypeDefinition myUnionBase = myUnion.getBaseType(); final List> myUnionBaseTypes = myUnionBase.getTypes(); @@ -500,8 +500,8 @@ public class YangParserTest { final IntegerTypeDefinition int16Ext = (IntegerTypeDefinition) myUnionBaseTypes.get(0); assertEquals(QName.create(BAR, "int16"), int16Ext.getQName()); - assertNull(int16Ext.getUnits()); - assertNull(int16Ext.getDefaultValue()); + assertEquals(Optional.empty(), int16Ext.getUnits()); + assertEquals(Optional.empty(), int16Ext.getDefaultValue()); final List ranges = int16Ext.getRangeConstraints(); assertEquals(1, ranges.size()); final RangeConstraint range = ranges.get(0); -- 2.36.6