+/*
+ * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.cluster.datastore.node.utils.transformer;
+
+import static org.junit.Assert.assertEquals;
+
+import com.google.common.collect.ImmutableMap;
+import java.io.IOException;
+import java.math.BigInteger;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Uint16;
+import org.opendaylight.yangtools.yang.common.Uint32;
+import org.opendaylight.yangtools.yang.common.Uint64;
+import org.opendaylight.yangtools.yang.common.Uint8;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeWriter;
+import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
+import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
+import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
+
+public class UintAdaptingPrunerTest {
+ private static final QName CONT = QName.create("urn:odl-ctlr1923", "cont");
+ private static final QName LST = QName.create(CONT, "lst");
+ private static final QName LFLST8 = QName.create(CONT, "lf-lst8");
+ private static final QName LFLST16 = QName.create(CONT, "lf-lst16");
+ private static final QName LFLST32 = QName.create(CONT, "lf-lst32");
+ private static final QName LFLST64 = QName.create(CONT, "lf-lst64");
+ private static final QName A = QName.create(LST, "a");
+ private static final QName B = QName.create(LST, "b");
+ private static final QName C = QName.create(LST, "c");
+ private static final QName D = QName.create(LST, "d");
+ private static final QName E = QName.create(LST, "e");
+ private static final QName F = QName.create(LST, "f");
+ private static final QName G = QName.create(LST, "g");
+ private static final QName H = QName.create(LST, "h");
+
+ private static EffectiveModelContext CONTEXT;
+
+ @BeforeClass
+ public static void beforeClass() {
+ CONTEXT = YangParserTestUtils.parseYangResource("/odl-ctlr1923.yang");
+ }
+
+ @Test
+ public void testListTranslation() throws IOException {
+ assertEquals(Builders.mapBuilder()
+ .withNodeIdentifier(new NodeIdentifier(LST))
+ .withChild(Builders.mapEntryBuilder()
+ .withNodeIdentifier(NodeIdentifierWithPredicates.of(LST, ImmutableMap.<QName, Object>builder()
+ .put(A, (byte) 1)
+ .put(B, (short) 1)
+ .put(C, 1)
+ .put(D, 1L)
+ .put(E, Uint8.ONE)
+ .put(F, Uint16.ONE)
+ .put(G, Uint32.ONE)
+ .put(H, Uint64.ONE)
+ .build()))
+ .withChild(ImmutableNodes.leafNode(A, (byte) 1))
+ .withChild(ImmutableNodes.leafNode(B, (short) 1))
+ .withChild(ImmutableNodes.leafNode(C, 1))
+ .withChild(ImmutableNodes.leafNode(D, 1L))
+ .withChild(ImmutableNodes.leafNode(E, Uint8.ONE))
+ .withChild(ImmutableNodes.leafNode(F, Uint16.ONE))
+ .withChild(ImmutableNodes.leafNode(G, Uint32.ONE))
+ .withChild(ImmutableNodes.leafNode(H, Uint64.ONE))
+ .build())
+ .build(),
+ prune(Builders.mapBuilder()
+ .withNodeIdentifier(new NodeIdentifier(LST))
+ .withChild(Builders.mapEntryBuilder()
+ .withNodeIdentifier(NodeIdentifierWithPredicates.of(LST, ImmutableMap.<QName, Object>builder()
+ .put(A, (byte) 1)
+ .put(B, (short) 1)
+ .put(C, 1)
+ .put(D, 1L)
+ .put(E, (short) 1)
+ .put(F, 1)
+ .put(G, 1L)
+ .put(H, BigInteger.ONE)
+ .build()))
+ .withChild(ImmutableNodes.leafNode(A, (byte) 1))
+ .withChild(ImmutableNodes.leafNode(B, (short) 1))
+ .withChild(ImmutableNodes.leafNode(C, 1))
+ .withChild(ImmutableNodes.leafNode(D, 1L))
+ .withChild(ImmutableNodes.leafNode(E, (short) 1))
+ .withChild(ImmutableNodes.leafNode(F, 1))
+ .withChild(ImmutableNodes.leafNode(G, 1L))
+ .withChild(ImmutableNodes.leafNode(H, BigInteger.ONE))
+ .build())
+ .build()));
+ }
+
+ @Test
+ public void testContainerTranslation() throws IOException {
+ assertEquals(Builders.containerBuilder()
+ .withNodeIdentifier(new NodeIdentifier(CONT))
+ .withChild(ImmutableNodes.leafNode(A, (byte) 1))
+ .withChild(ImmutableNodes.leafNode(B, (short) 1))
+ .withChild(ImmutableNodes.leafNode(C, 1))
+ .withChild(ImmutableNodes.leafNode(D, 1L))
+ .withChild(ImmutableNodes.leafNode(E, Uint8.ONE))
+ .withChild(ImmutableNodes.leafNode(F, Uint16.ONE))
+ .withChild(ImmutableNodes.leafNode(G, Uint32.ONE))
+ .withChild(ImmutableNodes.leafNode(H, Uint64.ONE))
+ .build(),
+ prune(Builders.containerBuilder()
+ .withNodeIdentifier(new NodeIdentifier(CONT))
+ .withChild(ImmutableNodes.leafNode(A, (byte) 1))
+ .withChild(ImmutableNodes.leafNode(B, (short) 1))
+ .withChild(ImmutableNodes.leafNode(C, 1))
+ .withChild(ImmutableNodes.leafNode(D, 1L))
+ .withChild(ImmutableNodes.leafNode(E, (short) 1))
+ .withChild(ImmutableNodes.leafNode(F, 1))
+ .withChild(ImmutableNodes.leafNode(G, 1L))
+ .withChild(ImmutableNodes.leafNode(H, BigInteger.ONE))
+ .build()));
+ }
+
+ @Test
+ public void testLeafList8() throws IOException {
+ assertEquals(Builders.leafSetBuilder()
+ .withNodeIdentifier(new NodeIdentifier(LFLST8))
+ .withChild(Builders.leafSetEntryBuilder()
+ .withNodeIdentifier(new NodeWithValue<>(LFLST8, Uint8.ONE))
+ .withValue(Uint8.ONE)
+ .build())
+ .build(),
+ prune(Builders.leafSetBuilder()
+ .withNodeIdentifier(new NodeIdentifier(LFLST8))
+ .withChild(Builders.leafSetEntryBuilder()
+ .withNodeIdentifier(new NodeWithValue<>(LFLST8, (short) 1))
+ .withValue((short) 1)
+ .build())
+ .build()));
+ }
+
+ @Test
+ public void testLeafList16() throws IOException {
+ assertEquals(Builders.leafSetBuilder()
+ .withNodeIdentifier(new NodeIdentifier(LFLST16))
+ .withChild(Builders.leafSetEntryBuilder()
+ .withNodeIdentifier(new NodeWithValue<>(LFLST16, Uint16.ONE))
+ .withValue(Uint16.ONE)
+ .build())
+ .build(),
+ prune(Builders.leafSetBuilder()
+ .withNodeIdentifier(new NodeIdentifier(LFLST16))
+ .withChild(Builders.leafSetEntryBuilder()
+ .withNodeIdentifier(new NodeWithValue<>(LFLST16, 1))
+ .withValue(1)
+ .build())
+ .build()));
+ }
+
+ @Test
+ public void testLeafList32() throws IOException {
+ assertEquals(Builders.leafSetBuilder()
+ .withNodeIdentifier(new NodeIdentifier(LFLST32))
+ .withChild(Builders.leafSetEntryBuilder()
+ .withNodeIdentifier(new NodeWithValue<>(LFLST32, Uint32.ONE))
+ .withValue(Uint32.ONE)
+ .build())
+ .build(),
+ prune(Builders.leafSetBuilder()
+ .withNodeIdentifier(new NodeIdentifier(LFLST32))
+ .withChild(Builders.leafSetEntryBuilder()
+ .withNodeIdentifier(new NodeWithValue<>(LFLST32, 1L))
+ .withValue(1L)
+ .build())
+ .build()));
+ }
+
+ @Test
+ public void testLeafList64() throws IOException {
+ assertEquals(Builders.leafSetBuilder()
+ .withNodeIdentifier(new NodeIdentifier(LFLST64))
+ .withChild(Builders.leafSetEntryBuilder()
+ .withNodeIdentifier(new NodeWithValue<>(LFLST64, Uint64.ONE))
+ .withValue(Uint64.ONE)
+ .build())
+ .build(),
+ prune(Builders.leafSetBuilder()
+ .withNodeIdentifier(new NodeIdentifier(LFLST64))
+ .withChild(Builders.leafSetEntryBuilder()
+ .withNodeIdentifier(new NodeWithValue<>(LFLST64, BigInteger.ONE))
+ .withValue(BigInteger.ONE)
+ .build())
+ .build()));
+ }
+
+ private static NormalizedNode<?, ?> prune(final NormalizedNode<?, ?> node) throws IOException {
+ final ReusableNormalizedNodePruner pruner = ReusableNormalizedNodePruner.forSchemaContext(CONTEXT)
+ .withUintAdaption();
+ pruner.initializeForPath(YangInstanceIdentifier.create(node.getIdentifier()));
+
+ try (NormalizedNodeWriter writer = NormalizedNodeWriter.forStreamWriter(pruner)) {
+ writer.write(node);
+ }
+ pruner.close();
+ return pruner.getResult().get();
+ }
+}