import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import java.net.URI;
-import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.annotation.RegEx;
import javax.xml.transform.dom.DOMSource;
// text value, i.e. a number, string, boolean or null
if (TEXT_NODE == childNode.getNodeType()) {
final String childNodeText = childNode.getNodeValue();
- final Matcher matcher = NUMBER_PATTERN.matcher(childNodeText);
- if (matcher.matches()) {
+ if (NUMBER_PATTERN.matcher(childNodeText).matches()) {
writer.value(parseNumber(childNodeText));
} else if ("true".equals(childNodeText) || "false".equals(childNodeText)) {
writer.value(Boolean.parseBoolean(childNodeText));
// json numbers are 64 bit wide floating point numbers - in java terms it is either long or double
private static Number parseNumber(final String numberText) {
- Matcher matcher = NOT_DECIMAL_NUMBER_PATTERN.matcher(numberText);
- if (matcher.matches()) {
- return Long.parseLong(numberText);
- } else {
- return Double.parseDouble(numberText);
+ if (NOT_DECIMAL_NUMBER_PATTERN.matcher(numberText).matches()) {
+ return Long.valueOf(numberText);
}
+
+ return Double.valueOf(numberText);
}
private static boolean isJsonObject(final Node firstChild) {
package org.opendaylight.yangtools.yang.data.codec.gson;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.opendaylight.yangtools.yang.data.codec.gson.TestUtils.loadTextFile;
final JsonParserStream jsonParser = JsonParserStream.create(streamWriter, schemaContext);
jsonParser.parse(new JsonReader(new StringReader(inputJson)));
final NormalizedNode<?, ?> transformedInput = result.getResult();
- assertNotNull(transformedInput instanceof UnkeyedListNode);
+ assertTrue(transformedInput instanceof UnkeyedListNode);
final UnkeyedListNode hop = (UnkeyedListNode) transformedInput;
final Optional<DataContainerChild<? extends PathArgument, ?>> lrsBits = hop.getChild(0).getChild(
return writer.toString();
}
- private ContainerNode createRootNode() {
+ private static ContainerNode createRootNode() {
LeafNode<byte[]> ipAddress = ImmutableNodes.leafNode(ipAddressQName, BaseEncoding.base64().decode("fwAAAQ=="));
return ImmutableContainerNodeBuilder.create().withNodeIdentifier(new NodeIdentifier(rootQName))
.withChild(ipAddress).build();
schemaContext = YangParserTestUtils.parseYangSources("/bug-6112/yang");
}
- private NormalizedNode<?, ?> readJson(final String jsonPath) throws IOException, URISyntaxException {
+ private static NormalizedNode<?, ?> readJson(final String jsonPath) throws IOException, URISyntaxException {
final String inputJson = loadTextFile(jsonPath);
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, schemaContext);
xmlParser.parse(reader);
assertNotNull(result.getResult());
}
}
- private void testInputXML(String xmlPath, String expectedValue) throws Exception {
+ private void testInputXML(final String xmlPath, final String expectedValue) throws Exception {
final InputStream resourceAsStream = XmlToNormalizedNodesTest.class.getResourceAsStream(xmlPath);
final XMLInputFactory factory = XMLInputFactory.newInstance();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, schemaContext);
xmlParser.parse(reader);
assertNotNull(result.getResult());
static {
XML_FACTORY = XMLOutputFactory.newFactory();
- XML_FACTORY.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, false);
+ XML_FACTORY.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, Boolean.FALSE);
}
private final QNameModule fooModuleQName;
static final XMLOutputFactory XML_FACTORY;
static {
XML_FACTORY = XMLOutputFactory.newFactory();
- XML_FACTORY.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, false);
+ XML_FACTORY.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, Boolean.FALSE);
}
private static ContainerNode augmentChoiceHell2() {
final NormalizedNodeBuilder<NodeIdentifier, Object, LeafNode<Object>> booleanBuilder = Builders
.leafBuilder().withNodeIdentifier(getNodeIdentifier("boolean"));
- booleanBuilder.withValue(false);
+ booleanBuilder.withValue(Boolean.FALSE);
b.withChild(booleanBuilder.build());
final ListNodeBuilder<Object, LeafSetEntryNode<Object>> leafListBuilder = Builders.leafSetBuilder()
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schema);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schema, schema);
xmlParser.parse(reader);
final NormalizedNode<?, ?> built = result.getResult();
final DOMResult domResult = new DOMResult(document);
final XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
- outputFactory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, true);
+ outputFactory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, Boolean.TRUE);
final XMLStreamWriter xmlStreamWriter = outputFactory.createXMLStreamWriter(domResult);
final DOMResult domResult = new DOMResult(UntrustedXML.newDocumentBuilder().newDocument());
final XMLOutputFactory factory = XMLOutputFactory.newInstance();
- factory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, true);
+ factory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, Boolean.TRUE);
final XMLStreamWriter xmlStreamWriter = factory.createXMLStreamWriter(domResult);
final DOMResult domResult = new DOMResult(UntrustedXML.newDocumentBuilder().newDocument());
final XMLOutputFactory factory = XMLOutputFactory.newInstance();
- factory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, true);
+ factory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, Boolean.TRUE);
final XMLStreamWriter xmlStreamWriter = factory.createXMLStreamWriter(domResult);
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, schemaContext);
xmlParser.parse(reader);
xmlParser.flush();
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, schemaContext);
xmlParser.parse(reader);
final NormalizedNode<?, ?> transformedInput = result.getResult();
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, schemaContext);
try {
xmlParser.parse(reader);
fail("IllegalStateException should have been thrown because of duplicate leaf.");
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, schemaContext);
try {
xmlParser.parse(reader);
fail("IllegalStateException should have been thrown because of duplicate anyxml");
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, schemaContext);
try {
xmlParser.parse(reader);
fail("IllegalStateException should have been thrown because of duplicate container");
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, schemaContext);
try {
xmlParser.parse(reader);
fail("XMLStreamException should have been thrown because of unterminated leaf element.");
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, schemaContext);
try {
xmlParser.parse(reader);
fail("XMLStreamException should have been thrown because of unterminated leaf element.");
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, schemaContext);
try {
xmlParser.parse(reader);
fail("XMLStreamException should have been thrown because of unterminated container element.");
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, schemaContext);
try {
xmlParser.parse(reader);
fail("IllegalStateException should have been thrown because of an unexisting container element.");
@Test
public void testRawAnyXMLFromBar() throws Exception {
- DataSchemaNode barContainer = schemaContext.getDataChildByName(QName.create(barModuleQName, "bar"));;
+ DataSchemaNode barContainer = schemaContext.getDataChildByName(QName.create(barModuleQName, "bar"));
assertTrue(barContainer instanceof ContainerSchemaNode);
final YangModeledAnyXmlSchemaNode yangModeledAnyXML = new YangModeledAnyXMLSchemaNodeImplTest(myAnyXMLDataBar,
(ContainerSchemaNode) barContainer);
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, schemaContext);
xmlParser.parse(reader);
final NormalizedNode<?, ?> output = result.build();
private final QName qName;
private final ContainerSchemaNode contentSchema;
- private YangModeledAnyXMLSchemaNodeImplTest(QName qName, ContainerSchemaNode contentSchema) {
+ private YangModeledAnyXMLSchemaNodeImplTest(final QName qName, final ContainerSchemaNode contentSchema) {
this.qName = qName;
this.contentSchema = contentSchema;
}
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
- final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext);
+ final XmlParserStream xmlParser = XmlParserStream.create(streamWriter, schemaContext, schemaContext);
xmlParser.parse(reader);
final NormalizedNode<?, ?> transformedInput = result.getResult();
final DOMResult domResult = new DOMResult(document);
final XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
- outputFactory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, true);
+ outputFactory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, Boolean.TRUE);
final XMLStreamWriter xmlStreamWriter = outputFactory.createXMLStreamWriter(domResult);
import com.google.common.collect.Iterables;
import java.util.Map;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
*
* @param <E> type of elements to be parsed
*/
-public abstract class LeafSetEntryNodeBaseParser<E> implements ExtensibleParser<YangInstanceIdentifier.NodeWithValue, E, LeafSetEntryNode<?>, LeafListSchemaNode> {
+public abstract class LeafSetEntryNodeBaseParser<E> implements ExtensibleParser<NodeWithValue, E, LeafSetEntryNode<?>, LeafListSchemaNode> {
- private final BuildingStrategy<YangInstanceIdentifier.NodeWithValue, LeafSetEntryNode<?>> buildingStrategy;
+ private final BuildingStrategy<NodeWithValue, LeafSetEntryNode<?>> buildingStrategy;
public LeafSetEntryNodeBaseParser() {
buildingStrategy = new SimpleLeafSetEntryBuildingStrategy();
}
- public LeafSetEntryNodeBaseParser(final BuildingStrategy<YangInstanceIdentifier.NodeWithValue, LeafSetEntryNode<?>> buildingStrategy) {
+ public LeafSetEntryNodeBaseParser(final BuildingStrategy<NodeWithValue, LeafSetEntryNode<?>> buildingStrategy) {
this.buildingStrategy = buildingStrategy;
}
@SuppressWarnings("unchecked")
@Override
- public final LeafSetEntryNode<?> parse(Iterable<E> elements, LeafListSchemaNode schema) {
+ public final LeafSetEntryNode<?> parse(final Iterable<E> elements, final LeafListSchemaNode schema) {
final int size = Iterables.size(elements);
Preconditions.checkArgument(size == 1, "Xml elements mapped to leaf node illegal count: %s", size);
final E e = elements.iterator().next();
Object value = parseLeafListEntry(e,schema);
- NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeWithValue, Object, LeafSetEntryNode<Object>> leafEntryBuilder = Builders
+ NormalizedNodeAttrBuilder<NodeWithValue, Object, LeafSetEntryNode<Object>> leafEntryBuilder = Builders
.leafSetEntryBuilder(schema);
leafEntryBuilder.withAttributes(getAttributes(e));
leafEntryBuilder.withValue(value);
*/
protected abstract Map<QName, String> getAttributes(E e);
- public static class SimpleLeafSetEntryBuildingStrategy implements BuildingStrategy<YangInstanceIdentifier.NodeWithValue, LeafSetEntryNode<?>> {
+ public static class SimpleLeafSetEntryBuildingStrategy implements BuildingStrategy<NodeWithValue, LeafSetEntryNode<?>> {
@Override
public LeafSetEntryNode<?> build(final NormalizedNodeBuilder<NodeWithValue, ?, LeafSetEntryNode<?>> builder) {
package org.opendaylight.yangtools.yang.data.impl.codecs;
import static org.junit.Assert.assertEquals;
+
import org.junit.Test;
import org.opendaylight.yangtools.yang.data.api.codec.BooleanCodec;
import org.opendaylight.yangtools.yang.model.util.type.BaseTypes;
@SuppressWarnings("unchecked")
@Test
public void testSerialize() {
- BooleanCodec<String> codec = TypeDefinitionAwareCodecTestHelper.getCodec(BaseTypes.booleanType(), BooleanCodec.class);
+ BooleanCodec<String> codec = TypeDefinitionAwareCodecTestHelper.getCodec(BaseTypes.booleanType(),
+ BooleanCodec.class);
assertEquals("serialize", "", codec.serialize(null));
- assertEquals("serialize", "true", codec.serialize(true));
- assertEquals("serialize", "false", codec.serialize(false));
+ assertEquals("serialize", "true", codec.serialize(Boolean.TRUE));
+ assertEquals("serialize", "false", codec.serialize(Boolean.FALSE));
}
@SuppressWarnings("unchecked")
@Test
public void testDeserialize() {
- BooleanCodec<String> codec = TypeDefinitionAwareCodecTestHelper.getCodec(BaseTypes.booleanType(), BooleanCodec.class);
+ BooleanCodec<String> codec = TypeDefinitionAwareCodecTestHelper.getCodec(BaseTypes.booleanType(),
+ BooleanCodec.class);
assertEquals("deserialize", Boolean.TRUE, codec.deserialize("true"));
assertEquals("deserialize", Boolean.TRUE, codec.deserialize("TRUE"));
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.mockito.Mockito.mock;
+
import java.io.File;
import java.io.FileNotFoundException;
import java.net.URISyntaxException;
private static final MapEntryNode LIST_MAIN_CHILD_1 = ImmutableNodes.mapEntry(LIST_MAIN, LIST_MAIN_CHILD_QNAME_1, 1);
private static final MapEntryNode LIST_MAIN_CHILD_2 = ImmutableNodes.mapEntry(LIST_MAIN, LIST_MAIN_CHILD_QNAME_1, 2);
private static final MapEntryNode LIST_MAIN_CHILD_3 = ImmutableNodes.mapEntry(LIST_MAIN, LIST_MAIN_CHILD_QNAME_1, 3);
- private static final Integer SIZE = 3;
- private static final NodeWithValue BAR_PATH = new NodeWithValue<>(LEAF_LIST_MAIN, "bar");
+ private static final int SIZE = 3;
+ private static final NodeWithValue<String> BAR_PATH = new NodeWithValue<>(LEAF_LIST_MAIN, "bar");
private static final LeafSetEntryNode LEAF_SET_ENTRY_NODE = ImmutableLeafSetEntryNodeBuilder.create()
.withNodeIdentifier(BAR_PATH)
.withValue("bar")
.build();
assertNotNull(Builders.orderedMapBuilder(list));
- assertEquals(SIZE, (Integer) orderedMapNodeCreateNull.getSize());
+ assertEquals(SIZE, orderedMapNodeCreateNull.getSize());
assertEquals(orderedMapNodeCreateNode.getSize(), orderedMapNodeCreateNull.getSize() - 1);
assertEquals(NODE_IDENTIFIER_LIST, orderedMapNodeCreateSize.getIdentifier());
- assertEquals(orderedMapNodeCreateNull.getChild(0), LIST_MAIN_CHILD_1);
- assertEquals((Integer) orderedMapNodeCreateNull.getValue().size(), SIZE);
- assertNotNull(orderedMapNodeCreateNull.hashCode());
- assertEquals((Integer) orderedMapNodeCreateNull.getValue().size(), SIZE);
+ assertEquals(LIST_MAIN_CHILD_1, orderedMapNodeCreateNull.getChild(0));
+ assertEquals(SIZE, orderedMapNodeCreateNull.getValue().size());
assertEquals(orderedMapNodeSchemaAware.getChild(0), orderedMapNodeSchemaAwareMapNodeConst.getChild(0));
}
assertNotNull(Builders.orderedLeafSetBuilder(leafList));
assertNotNull(Builders.anyXmlBuilder());
- assertNotNull(orderedLeafSetShemaAware.hashCode());
assertNotNull(orderedLeafSetShemaAware);
assertEquals(1, ((OrderedLeafSetNode<?>)orderedLeafSet).getSize());
assertEquals("baz", ((OrderedLeafSetNode<?>)orderedLeafSet).getChild(0).getValue());
collectionNodeBuilder.withNodeIdentifier(NODE_IDENTIFIER_LEAF_LIST);
collectionNodeBuilder.withValue(mapEntryNodeColl);
final MapNode mapNode = collectionNodeBuilder.build();
- assertNotNull(mapNode.hashCode());
final MapNode mapNodeSchemaAware = ImmutableMapNodeSchemaAwareBuilder.create(list, getImmutableMapNode()).build();
assertNotNull(mapNodeSchemaAware);
assertNotNull(Builders.mapBuilder(mapNode));
} catch (IndexOutOfBoundsException e) {
}
- assertNotNull(unkeyedListNodeSize.getSize());
assertNotNull(unkeyedListNodeSize.getValue());
assertEquals(unkeyedListEntryNode, unkeyedListNodeCreated.getChild(0));
assertEquals(unkeyedListNode.getNodeType().getLocalName(), unkeyedListNodeSize.getNodeType()
package org.opendaylight.yangtools.yang.data.impl.schema;
import com.google.common.base.Preconditions;
-import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import java.io.File;
import java.io.FileNotFoundException;
import java.net.URI;
import java.net.URISyntaxException;
+import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.junit.Before;
}
private static DataSchemaNode findChildNode(final Iterable<DataSchemaNode> children, final String name) {
- List<DataNodeContainer> containers = Lists.newArrayList();
+ List<DataNodeContainer> containers = new ArrayList<>();
for (DataSchemaNode dataSchemaNode : children) {
if (dataSchemaNode.getQName().getLocalName().equals(name)) {
XMLAssert.assertXMLIdentical(new Diff(EXPECTED_2, stringWriter.toString()), true);
}
- private SchemaContext getSchemaContext(final String filePath) throws URISyntaxException, ReactorException, FileNotFoundException {
+ private static SchemaContext getSchemaContext(final String filePath) throws URISyntaxException,
+ ReactorException, FileNotFoundException {
return YangParserTestUtils.parseYangSource(filePath);
}
static {
XML_FACTORY = XMLOutputFactory.newFactory();
- XML_FACTORY.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, false);
+ XML_FACTORY.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, Boolean.FALSE);
}
private QNameModule fooModuleQName;
static {
XML_FACTORY = XMLOutputFactory.newFactory();
- XML_FACTORY.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, false);
+ XML_FACTORY.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, Boolean.FALSE);
}
private final QNameModule fooModuleQName;
final NormalizedNodeBuilder<NodeIdentifier, Object, LeafNode<Object>> booleanBuilder = Builders
.leafBuilder().withNodeIdentifier(getNodeIdentifier("boolean"));
- booleanBuilder.withValue(false);
+ booleanBuilder.withValue(Boolean.FALSE);
b.withChild(booleanBuilder.build());
final ListNodeBuilder<Object, LeafSetEntryNode<Object>> leafListBuilder = Builders.leafSetBuilder()
static final XMLOutputFactory XML_FACTORY;
static {
XML_FACTORY = XMLOutputFactory.newFactory();
- XML_FACTORY.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, false);
+ XML_FACTORY.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, Boolean.FALSE);
}
private static void writeNormalizedNode(final NormalizedNode<?, ?> normalized, final DOMResult result,
static {
XML_FACTORY = XMLOutputFactory.newFactory();
- XML_FACTORY.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, false);
+ XML_FACTORY.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, Boolean.FALSE);
}
private QNameModule fooModuleQName;
static {
XML_FACTORY = XMLOutputFactory.newFactory();
- XML_FACTORY.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, false);
+ XML_FACTORY.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, Boolean.FALSE);
}
private final QNameModule bazModuleQName;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
// TODO: expand these tests to catch some more obscure cases
public class ConfigStatementValidationTest {
- private static final Logger LOG = LoggerFactory.getLogger(ConfigStatementValidationTest.class);
-
private static final Short ONE_ID = 1;
private static final Short TWO_ID = 2;
result = prime * result + Objects.hashCode(def.getMustConstraints());
result = prime * result + Objects.hashCode(def.getMinElements());
result = prime * result + Objects.hashCode(def.getMaxElements());
- result = prime * result + Objects.hashCode(def.isMandatory());
+ result = prime * result + Boolean.hashCode(def.isMandatory());
return result;
}
Code Review / yangtools.git / commitdiff