codec/yang-data-codec-binfmt/src/test/java/org/opendaylight/yangtools/yang/data/codec/binfmt/TestModel.java

   1 /*
   2  * Copyright (c) 2014, 2015 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 package org.opendaylight.yangtools.yang.data.codec.binfmt;
   9
  10 import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapEntry;
  11 import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapEntryBuilder;
  12 import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapNodeBuilder;
  13
  14 import com.google.common.collect.ImmutableList;
  15 import com.google.common.collect.ImmutableSet;
  16 import java.math.BigDecimal;
  17 import java.util.HashMap;
  18 import java.util.HashSet;
  19 import java.util.Map;
  20 import java.util.Set;
  21 import java.util.function.Function;
  22 import org.opendaylight.yangtools.yang.common.QName;
  23 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  24 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
  25 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  26 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
  27 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
  28 import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
  29 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  30 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
  31 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
  32 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
  33 import org.opendaylight.yangtools.yang.data.api.schema.SystemLeafSetNode;
  34 import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
  35 import org.opendaylight.yangtools.yang.data.api.schema.builder.DataContainerNodeBuilder;
  36 import org.opendaylight.yangtools.yang.data.api.schema.builder.NormalizedNodeBuilder;
  37 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
  38 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
  39 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
  40 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetEntryNodeBuilder;
  41 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetNodeBuilder;
  42 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapEntryNodeBuilder;
  43
  44 public final class TestModel {
  45
  46     static final QName TEST_QNAME = QName.create(
  47             "urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test",
  48             "2014-03-13", "test");
  49
  50     static final QName AUG_NAME_QNAME = QName.create(
  51             "urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:aug",
  52             "2014-03-13", "name");
  53
  54     private static final QName AUG_CONT_QNAME = QName.create(
  55             "urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:aug",
  56             "2014-03-13", "cont");
  57
  58     static final QName DESC_QNAME = QName.create(TEST_QNAME, "desc");
  59     static final QName SOME_BINARY_DATA_QNAME = QName.create(TEST_QNAME, "some-binary-data");
  60     static final QName BINARY_LEAF_LIST_QNAME = QName.create(TEST_QNAME, "binary_leaf_list");
  61     private static final QName SOME_REF_QNAME = QName.create(TEST_QNAME, "some-ref");
  62     private static final QName MYIDENTITY_QNAME = QName.create(TEST_QNAME, "myidentity");
  63     private static final QName SWITCH_FEATURES_QNAME = QName.create(TEST_QNAME, "switch-features");
  64
  65     private static final QName AUGMENTED_LIST_QNAME = QName.create(TEST_QNAME, "augmented-list");
  66     static final QName AUGMENTED_LIST_ENTRY_QNAME = QName.create(TEST_QNAME, "augmented-list-entry");
  67
  68     static final QName OUTER_LIST_QNAME = QName.create(TEST_QNAME, "outer-list");
  69     static final QName INNER_LIST_QNAME = QName.create(TEST_QNAME, "inner-list");
  70     static final QName ID_QNAME = QName.create(TEST_QNAME, "id");
  71     private static final QName NAME_QNAME = QName.create(TEST_QNAME, "name");
  72     static final QName BOOLEAN_LEAF_QNAME = QName.create(TEST_QNAME, "boolean-leaf");
  73     private static final QName SHORT_LEAF_QNAME = QName.create(TEST_QNAME, "short-leaf");
  74     private static final QName BYTE_LEAF_QNAME = QName.create(TEST_QNAME, "byte-leaf");
  75     private static final QName BIGINTEGER_LEAF_QNAME = QName.create(TEST_QNAME, "biginteger-leaf");
  76     private static final QName BIGDECIMAL_LEAF_QNAME = QName.create(TEST_QNAME, "bigdecimal-leaf");
  77     static final QName ORDERED_LIST_QNAME = QName.create(TEST_QNAME, "ordered-list");
  78     static final QName ORDERED_LIST_ENTRY_QNAME = QName.create(TEST_QNAME, "ordered-list-leaf");
  79     private static final QName UNKEYED_LIST_QNAME = QName.create(TEST_QNAME, "unkeyed-list");
  80     private static final QName SHOE_QNAME = QName.create(TEST_QNAME, "shoe");
  81     static final QName ANY_XML_QNAME = QName.create(TEST_QNAME, "any");
  82     static final QName EMPTY_QNAME = QName.create(TEST_QNAME, "empty-leaf");
  83
  84     static final YangInstanceIdentifier TEST_PATH = YangInstanceIdentifier.of(TEST_QNAME);
  85     private static final QName TWO_THREE_QNAME = QName.create(TEST_QNAME, "two");
  86     private static final QName TWO_QNAME = QName.create(TEST_QNAME, "two");
  87
  88     private static final Integer ONE_ID = 1;
  89     private static final Integer TWO_ID = 2;
  90     private static final String TWO_ONE_NAME = "one";
  91     private static final String TWO_TWO_NAME = "two";
  92     private static final String DESC = "Hello there";
  93     private static final Boolean ENABLED = true;
  94     private static final Short SHORT_ID = 1;
  95     private static final Byte BYTE_ID = 1;
  96     // Family specific constants
  97     private static final QName FAMILY_QNAME = QName.create(
  98         "urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:notification-test", "2014-04-17", "family");
  99     private static final QName CHILDREN_QNAME = QName.create(FAMILY_QNAME, "children");
 100     static final QName CHILD_NUMBER_QNAME = QName.create(FAMILY_QNAME, "child-number");
 101     static final QName CHILD_NAME_QNAME = QName.create(FAMILY_QNAME, "child-name");
 102
 103     private static final String FIRST_CHILD_NAME = "first child";
 104
 105     private static final MapEntryNode BAR_NODE = mapEntryBuilder(
 106             OUTER_LIST_QNAME, ID_QNAME, TWO_ID)
 107             .withChild(mapNodeBuilder(INNER_LIST_QNAME)
 108                     .withChild(mapEntry(INNER_LIST_QNAME, NAME_QNAME, TWO_ONE_NAME))
 109                     .withChild(mapEntry(INNER_LIST_QNAME, NAME_QNAME, TWO_TWO_NAME))
 110                     .build())
 111             .build();
 112
 113     private TestModel() {
 114         throw new UnsupportedOperationException();
 115     }
 116
 117     public static DataContainerNodeBuilder<NodeIdentifier, ContainerNode> createBaseTestContainerBuilder(
 118             final Function<String, Number> uint64) {
 119         // Create a list of shoes
 120         // This is to test leaf list entry
 121         final LeafSetEntryNode<Object> nike = ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier(
 122                 new NodeWithValue<>(SHOE_QNAME, "nike")).withValue("nike").build();
 123
 124         final LeafSetEntryNode<Object> puma = ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier(
 125                 new NodeWithValue<>(SHOE_QNAME, "puma")).withValue("puma").build();
 126
 127         final SystemLeafSetNode<Object> shoes = ImmutableLeafSetNodeBuilder.create().withNodeIdentifier(
 128                 new NodeIdentifier(SHOE_QNAME)).withChild(nike).withChild(puma).build();
 129
 130         // Test a leaf-list where each entry contains an identity
 131         final LeafSetEntryNode<Object> cap1 =
 132                 ImmutableLeafSetEntryNodeBuilder
 133                         .create()
 134                         .withNodeIdentifier(
 135                                 new NodeWithValue<>(QName.create(
 136                                         TEST_QNAME, "capability"), DESC_QNAME))
 137                         .withValue(DESC_QNAME).build();
 138
 139         final SystemLeafSetNode<Object> capabilities =
 140                 ImmutableLeafSetNodeBuilder
 141                         .create()
 142                         .withNodeIdentifier(
 143                                 new NodeIdentifier(QName.create(
 144                                         TEST_QNAME, "capability"))).withChild(cap1).build();
 145
 146         ContainerNode switchFeatures =
 147                 ImmutableContainerNodeBuilder
 148                         .create()
 149                         .withNodeIdentifier(
 150                                 new NodeIdentifier(SWITCH_FEATURES_QNAME))
 151                         .withChild(capabilities).build();
 152
 153         // Create a leaf list with numbers
 154         final LeafSetEntryNode<Object> five =
 155                 ImmutableLeafSetEntryNodeBuilder
 156                         .create()
 157                         .withNodeIdentifier(
 158                                 new NodeWithValue<>(QName.create(
 159                                         TEST_QNAME, "number"), 5)).withValue(5).build();
 160         final LeafSetEntryNode<Object> fifteen =
 161                 ImmutableLeafSetEntryNodeBuilder
 162                         .create()
 163                         .withNodeIdentifier(
 164                                 new NodeWithValue<>(QName.create(
 165                                         TEST_QNAME, "number"), 15)).withValue(15).build();
 166         final SystemLeafSetNode<Object> numbers =
 167                 ImmutableLeafSetNodeBuilder
 168                         .create()
 169                         .withNodeIdentifier(
 170                                 new NodeIdentifier(QName.create(
 171                                         TEST_QNAME, "number"))).withChild(five).withChild(fifteen)
 172                         .build();
 173
 174
 175         // Create augmentations
 176         MapEntryNode augMapEntry = createAugmentedListEntry(1, "First Test");
 177
 178         // Create a bits leaf
 179         NormalizedNodeBuilder<NodeIdentifier, Object, LeafNode<Object>>
 180                 myBits = Builders.leafBuilder()
 181                 .withNodeIdentifier(new NodeIdentifier(QName.create(TEST_QNAME, "my-bits")))
 182                 .withValue(ImmutableSet.of("foo", "bar"));
 183
 184         // Create unkeyed list entry
 185         UnkeyedListEntryNode unkeyedListEntry =
 186                 Builders.unkeyedListEntryBuilder().withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(
 187                     UNKEYED_LIST_QNAME)).withChild(ImmutableNodes.leafNode(NAME_QNAME, "unkeyed-entry-name")).build();
 188
 189         // Create YangInstanceIdentifier with all path arg types.
 190         YangInstanceIdentifier instanceID = YangInstanceIdentifier.create(
 191                 new NodeIdentifier(QName.create(TEST_QNAME, "qname")),
 192                 NodeIdentifierWithPredicates.of(QName.create(TEST_QNAME, "list-entry"),
 193                         QName.create(TEST_QNAME, "key"), 10),
 194                 new AugmentationIdentifier(ImmutableSet.of(
 195                         QName.create(TEST_QNAME, "aug1"), QName.create(TEST_QNAME, "aug2"))),
 196                 new NodeWithValue<>(QName.create(TEST_QNAME, "leaf-list-entry"), "foo"));
 197
 198         Map<QName, Object> keyValues = new HashMap<>();
 199         keyValues.put(CHILDREN_QNAME, FIRST_CHILD_NAME);
 200
 201
 202         // Create the document
 203         return ImmutableContainerNodeBuilder
 204                 .create()
 205                 .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TEST_QNAME))
 206                 .withChild(myBits.build())
 207                 .withChild(ImmutableNodes.leafNode(DESC_QNAME, DESC))
 208                 .withChild(ImmutableNodes.leafNode(BOOLEAN_LEAF_QNAME, ENABLED))
 209                 .withChild(ImmutableNodes.leafNode(SHORT_LEAF_QNAME, SHORT_ID))
 210                 .withChild(ImmutableNodes.leafNode(BYTE_LEAF_QNAME, BYTE_ID))
 211                 .withChild(ImmutableNodes.leafNode(TestModel.BIGINTEGER_LEAF_QNAME, uint64.apply("100")))
 212                 .withChild(ImmutableNodes.leafNode(TestModel.BIGDECIMAL_LEAF_QNAME, BigDecimal.valueOf(1.2)))
 213                 .withChild(ImmutableNodes.leafNode(SOME_REF_QNAME, instanceID))
 214                 .withChild(ImmutableNodes.leafNode(MYIDENTITY_QNAME, DESC_QNAME))
 215                 .withChild(Builders.unkeyedListBuilder()
 216                         .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(UNKEYED_LIST_QNAME))
 217                         .withChild(unkeyedListEntry).build())
 218                 .withChild(Builders.choiceBuilder()
 219                         .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TWO_THREE_QNAME))
 220                         .withChild(ImmutableNodes.leafNode(TWO_QNAME, "two")).build())
 221                 .withChild(Builders.orderedMapBuilder()
 222                         .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(ORDERED_LIST_QNAME))
 223                         .withValue(ImmutableList.<MapEntryNode>builder().add(
 224                                 mapEntryBuilder(ORDERED_LIST_QNAME, ORDERED_LIST_ENTRY_QNAME, "1").build(),
 225                                 mapEntryBuilder(ORDERED_LIST_QNAME, ORDERED_LIST_ENTRY_QNAME, "2").build()).build())
 226                         .build())
 227                 .withChild(shoes)
 228                 .withChild(numbers)
 229                 .withChild(switchFeatures)
 230                 .withChild(mapNodeBuilder(AUGMENTED_LIST_QNAME).withChild(augMapEntry).build())
 231                 .withChild(mapNodeBuilder(OUTER_LIST_QNAME)
 232                                 .withChild(mapEntry(OUTER_LIST_QNAME, ID_QNAME, ONE_ID))
 233                                 .withChild(BAR_NODE).build()
 234                 );
 235     }
 236
 237     static ContainerNode createTestContainer(final Function<String, Number> uint64) {
 238         return createBaseTestContainerBuilder(uint64).build();
 239     }
 240
 241     private static MapEntryNode createAugmentedListEntry(final int id, final String name) {
 242
 243         Set<QName> childAugmentations = new HashSet<>();
 244         childAugmentations.add(AUG_CONT_QNAME);
 245
 246         ContainerNode augCont =
 247                 ImmutableContainerNodeBuilder
 248                         .create()
 249                         .withNodeIdentifier(
 250                                 new YangInstanceIdentifier.NodeIdentifier(AUG_CONT_QNAME))
 251                         .withChild(ImmutableNodes.leafNode(AUG_NAME_QNAME, name)).build();
 252
 253
 254         final YangInstanceIdentifier.AugmentationIdentifier augmentationIdentifier =
 255                 new YangInstanceIdentifier.AugmentationIdentifier(childAugmentations);
 256
 257         final AugmentationNode augmentationNode =
 258                 Builders.augmentationBuilder()
 259                         .withNodeIdentifier(augmentationIdentifier).withChild(augCont)
 260                         .build();
 261
 262         return ImmutableMapEntryNodeBuilder
 263                 .create()
 264                 .withNodeIdentifier(
 265                         YangInstanceIdentifier.NodeIdentifierWithPredicates.of(
 266                                 AUGMENTED_LIST_QNAME, ID_QNAME, id))
 267                 .withChild(ImmutableNodes.leafNode(ID_QNAME, id))
 268                 .withChild(augmentationNode).build();
 269     }
 270 }