data/yang-data-impl/src/test/java/org/opendaylight/yangtools/yang/data/impl/schema/ImmutableNormalizedNodeStreamWriterTest.java

   1 /*
   2  * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   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
   7  */
   8
   9 package org.opendaylight.yangtools.yang.data.impl.schema;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import static org.junit.Assert.assertNotNull;
  13
  14 import com.google.common.collect.ImmutableSet;
  15 import java.io.IOException;
  16 import java.text.ParseException;
  17 import java.util.List;
  18 import java.util.Map;
  19 import javax.xml.transform.dom.DOMSource;
  20 import org.junit.Before;
  21 import org.junit.Test;
  22 import org.opendaylight.yangtools.yang.common.QName;
  23 import org.opendaylight.yangtools.yang.common.QNameModule;
  24 import org.opendaylight.yangtools.yang.common.Revision;
  25 import org.opendaylight.yangtools.yang.common.XMLNamespace;
  26 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
  27 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  28 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
  29 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
  30 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  31 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeWriter;
  32
  33 public class ImmutableNormalizedNodeStreamWriterTest {
  34
  35     private QNameModule bazModule;
  36
  37     private QName outerContainer;
  38
  39     private QName myContainer1;
  40     private QName myKeyedList;
  41     private QName myKeyLeaf;
  42     private QName myLeafInList1;
  43     private QName myLeafInList2;
  44     private QName myOrderedList;
  45     private QName myKeyLeafInOrderedList;
  46     private QName myLeafInOrderedList1;
  47     private QName myLeafInOrderedList2;
  48     private QName myUnkeyedList;
  49     private QName myLeafInUnkeyedList;
  50     private QName myLeaf1;
  51     private QName myLeafList;
  52     private QName myOrderedLeafList;
  53
  54     private QName myContainer2;
  55     private QName innerContainer;
  56     private QName myLeaf2;
  57     private QName myLeaf3;
  58     private QName myChoice;
  59     private QName myLeafInCase2;
  60     private QName myAnyxml;
  61
  62     private QName myContainer3;
  63     private QName myDoublyKeyedList;
  64     private QName myFirstKeyLeaf;
  65     private QName mySecondKeyLeaf;
  66     private QName myLeafInList3;
  67
  68     private DOMSource anyxmlDomSource;
  69
  70     @Before
  71     public void setup() throws ParseException {
  72         bazModule = QNameModule.create(XMLNamespace.of("baz-namespace"), Revision.of("1970-01-01"));
  73
  74         outerContainer = QName.create(bazModule, "outer-container");
  75
  76         myContainer1 = QName.create(bazModule, "my-container-1");
  77         myKeyedList = QName.create(bazModule, "my-keyed-list");
  78         myKeyLeaf = QName.create(bazModule, "my-key-leaf");
  79         myLeafInList1 = QName.create(bazModule, "my-leaf-in-list-1");
  80         myLeafInList2 = QName.create(bazModule, "my-leaf-in-list-2");
  81         myOrderedList = QName.create(bazModule, "my-ordered-list");
  82         myKeyLeafInOrderedList = QName.create(bazModule, "my-key-leaf-in-ordered-list");
  83         myLeafInOrderedList1 = QName.create(bazModule, "my-leaf-in-ordered-list-1");
  84         myLeafInOrderedList2 = QName.create(bazModule, "my-leaf-in-ordered-list-2");
  85         myUnkeyedList = QName.create(bazModule, "my-unkeyed-list");
  86         myLeafInUnkeyedList = QName.create(bazModule, "my-leaf-in-unkeyed-list");
  87         myLeaf1 = QName.create(bazModule, "my-leaf-1");
  88         myLeafList = QName.create(bazModule, "my-leaf-list");
  89         myOrderedLeafList = QName.create(bazModule, "my-ordered-leaf-list");
  90
  91         myContainer2 = QName.create(bazModule, "my-container-2");
  92         innerContainer = QName.create(bazModule, "inner-container");
  93         myLeaf2 = QName.create(bazModule, "my-leaf-2");
  94         myLeaf3 = QName.create(bazModule, "my-leaf-3");
  95         myChoice = QName.create(bazModule, "my-choice");
  96         myLeafInCase2 = QName.create(bazModule, "my-leaf-in-case-2");
  97         myAnyxml = QName.create(bazModule, "my-anyxml");
  98
  99         myContainer3 = QName.create(bazModule, "my-container-3");
 100         myDoublyKeyedList = QName.create(bazModule, "my-doubly-keyed-list");
 101         myFirstKeyLeaf = QName.create(bazModule, "my-first-key-leaf");
 102         mySecondKeyLeaf = QName.create(bazModule, "my-second-key-leaf");
 103         myLeafInList3 = QName.create(bazModule, "my-leaf-in-list-3");
 104
 105         anyxmlDomSource = new DOMSource();
 106     }
 107
 108     @Test
 109     public void testImmutableNormalizedNodeStreamWriter() throws IOException {
 110         final var result = new NormalizationResultHolder();
 111         final var immutableNormalizedNodeStreamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
 112         final var normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(immutableNormalizedNodeStreamWriter);
 113         normalizedNodeWriter.write(buildOuterContainerNode());
 114
 115         final var output = result.getResult().data();
 116         assertNotNull(output);
 117
 118         final var expectedNormalizedNode = buildOuterContainerNode();
 119         assertNotNull(expectedNormalizedNode);
 120
 121         assertEquals(expectedNormalizedNode, output);
 122     }
 123
 124     private ContainerNode buildOuterContainerNode() {
 125         return Builders.containerBuilder()
 126             .withNodeIdentifier(new NodeIdentifier(outerContainer))
 127             .withChild(Builders.containerBuilder()
 128                 .withNodeIdentifier(new NodeIdentifier(myContainer1))
 129                 .withChild(Builders.mapBuilder()
 130                     .withNodeIdentifier(new NodeIdentifier(myKeyedList))
 131                     .withChild(Builders.mapEntryBuilder()
 132                         .withNodeIdentifier(NodeIdentifierWithPredicates.of(myKeyedList, myKeyLeaf, "listkeyvalue1"))
 133                         .withChild(ImmutableNodes.leafNode(myLeafInList1, "listleafvalue1"))
 134                         .withChild(ImmutableNodes.leafNode(myLeafInList2, "listleafvalue2"))
 135                         .build())
 136                     .withChild(Builders.mapEntryBuilder()
 137                         .withNodeIdentifier(NodeIdentifierWithPredicates.of(myKeyedList, myKeyLeaf, "listkeyvalue2"))
 138                         .withChild(ImmutableNodes.leafNode(myLeafInList1, "listleafvalue12"))
 139                         .withChild(ImmutableNodes.leafNode(myLeafInList2, "listleafvalue22"))
 140                         .build())
 141                     .build())
 142                 .withChild(Builders.orderedMapBuilder()
 143                     .withNodeIdentifier(new NodeIdentifier(myOrderedList))
 144                     .withChild(Builders.mapEntryBuilder()
 145                         .withNodeIdentifier(
 146                             NodeIdentifierWithPredicates.of(myOrderedList, myKeyLeafInOrderedList, "olistkeyvalue1"))
 147                         .withChild(ImmutableNodes.leafNode(myLeafInOrderedList1, "olistleafvalue1"))
 148                         .withChild(ImmutableNodes.leafNode(myLeafInOrderedList2, "olistleafvalue2"))
 149                         .build())
 150                     .withChild(Builders.mapEntryBuilder()
 151                         .withNodeIdentifier(
 152                             NodeIdentifierWithPredicates.of(myOrderedList, myKeyLeafInOrderedList, "olistkeyvalue2"))
 153                         .withChild(ImmutableNodes.leafNode(myLeafInOrderedList1, "olistleafvalue12"))
 154                         .withChild(ImmutableNodes.leafNode(myLeafInOrderedList2, "olistleafvalue22"))
 155                         .build())
 156                     .build())
 157                 .withChild(Builders.unkeyedListBuilder()
 158                     .withNodeIdentifier(new NodeIdentifier(myUnkeyedList))
 159                     .withValue(List.of(Builders.unkeyedListEntryBuilder()
 160                         .withNodeIdentifier(new NodeIdentifier(myLeafInUnkeyedList))
 161                         .withChild(ImmutableNodes.leafNode(myLeafInUnkeyedList, "foo"))
 162                         .build()))
 163                     .build())
 164                 .withChild(ImmutableNodes.leafNode(myLeaf1, "value1"))
 165                 .withChild(Builders.leafSetBuilder()
 166                     .withNodeIdentifier(new NodeIdentifier(myLeafList))
 167                     .withChild(Builders.leafSetEntryBuilder().withNodeIdentifier(
 168                             new NodeWithValue<>(myLeafList, "lflvalue1")).withValue("lflvalue1").build())
 169                     .withChild(Builders.leafSetEntryBuilder().withNodeIdentifier(
 170                             new NodeWithValue<>(myLeafList, "lflvalue2")).withValue("lflvalue2").build())
 171                     .build())
 172                 .withChild(Builders.orderedLeafSetBuilder()
 173                     .withNodeIdentifier(new NodeIdentifier(myOrderedLeafList))
 174                     .withChild(Builders.leafSetEntryBuilder()
 175                         .withNodeIdentifier(
 176                             new NodeWithValue<>(myOrderedLeafList, "olflvalue1")).withValue("olflvalue1").build())
 177                     .withChild(Builders.leafSetEntryBuilder().withNodeIdentifier(
 178                             new NodeWithValue<>(myOrderedLeafList, "olflvalue2")).withValue("olflvalue2").build())
 179                     .build())
 180                 .build())
 181             .withChild(Builders.containerBuilder()
 182                 .withNodeIdentifier(new NodeIdentifier(myContainer2))
 183                 .withChild(Builders.containerBuilder()
 184                     .withNodeIdentifier(new NodeIdentifier(innerContainer))
 185                     .withChild(ImmutableNodes.leafNode(myLeaf2, "value2"))
 186                     .build())
 187                 .withChild(ImmutableNodes.leafNode(myLeaf3, "value3"))
 188                 .withChild(Builders.choiceBuilder()
 189                     .withNodeIdentifier(new NodeIdentifier(myChoice))
 190                     .withChild(ImmutableNodes.leafNode(myLeafInCase2, "case2value"))
 191                     .build())
 192                 .withChild(Builders.anyXmlBuilder()
 193                     .withNodeIdentifier(new NodeIdentifier(myAnyxml))
 194                     .withValue(anyxmlDomSource)
 195                     .build())
 196                 .build())
 197             .withChild(Builders.augmentationBuilder()
 198                 .withNodeIdentifier(new AugmentationIdentifier(ImmutableSet.of(myContainer3)))
 199                 .withChild(Builders.containerBuilder()
 200                     .withNodeIdentifier(new NodeIdentifier(myContainer3))
 201                     .withChild(Builders.augmentationBuilder()
 202                         .withNodeIdentifier(new AugmentationIdentifier(ImmutableSet.of(myDoublyKeyedList)))
 203                         .withChild(Builders.mapBuilder()
 204                             .withNodeIdentifier(new NodeIdentifier(myDoublyKeyedList))
 205                             .withChild(Builders.mapEntryBuilder()
 206                                 .withNodeIdentifier(NodeIdentifierWithPredicates.of(myDoublyKeyedList,
 207                                     Map.of(myFirstKeyLeaf, "listkeyvalue1", mySecondKeyLeaf, "listkeyvalue2")))
 208                                 .withChild(ImmutableNodes.leafNode(myLeafInList3, "listleafvalue1"))
 209                                 .build())
 210                             .build())
 211                         .build())
 212                     .build())
 213                 .build())
 214             .build();
 215     }
 216 }