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

   1 /*
   2  * Copyright (c) 2022 PANTHEON.tech, s.r.o. 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.impl.schema.nodes;
   9
  10 import static org.junit.Assert.assertNotEquals;
  11 import static org.junit.jupiter.api.Assertions.assertEquals;
  12 import static org.mockito.Mockito.doReturn;
  13 import static org.mockito.Mockito.mock;
  14
  15 import java.util.List;
  16 import org.junit.Test;
  17 import org.junit.runner.RunWith;
  18 import org.mockito.junit.MockitoJUnitRunner;
  19 import org.opendaylight.yangtools.yang.common.QName;
  20 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  21 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
  22 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  23 import org.opendaylight.yangtools.yang.data.api.schema.SystemLeafSetNode;
  24 import org.opendaylight.yangtools.yang.data.api.schema.UserLeafSetNode;
  25 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
  26 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
  27
  28 @RunWith(MockitoJUnitRunner.StrictStubs.class)
  29 public class YT1417Test {
  30     public static final QName FOO = QName.create("foo", "foo");
  31     public static final QName BAR = QName.create("foo", "bar");
  32
  33     @Test
  34     public void testContainerNodeEquality() {
  35         final var mock = mock(ContainerNode.class);
  36         doReturn(new NodeIdentifier(FOO)).when(mock).getIdentifier();
  37         doReturn(1).when(mock).size();
  38         doReturn(ImmutableNodes.leafNode(BAR, "abc")).when(mock).childByArg(new NodeIdentifier(BAR));
  39
  40         assertEquals(Builders.containerBuilder()
  41             .withNodeIdentifier(new NodeIdentifier(FOO))
  42             .withChild(ImmutableNodes.leafNode(BAR, "abc"))
  43             .build(), mock);
  44
  45         // Mismatched identifier
  46         assertNotEquals(Builders.containerBuilder()
  47             .withNodeIdentifier(new NodeIdentifier(BAR))
  48             .withChild(ImmutableNodes.leafNode(BAR, "abc"))
  49             .build(), mock);
  50
  51         // Mismatched child size
  52         assertNotEquals(Builders.containerBuilder()
  53             .withNodeIdentifier(new NodeIdentifier(FOO))
  54             .withChild(ImmutableNodes.leafNode(FOO, "abc"))
  55             .withChild(ImmutableNodes.leafNode(BAR, "abc"))
  56             .build(), mock);
  57
  58         // Mismatched child
  59         assertNotEquals(Builders.containerBuilder()
  60             .withNodeIdentifier(new NodeIdentifier(FOO))
  61             .withChild(ImmutableNodes.leafNode(FOO, "abc"))
  62             .build(), mock);
  63     }
  64
  65     @Test
  66     public void testSystemLeafSetNodeEquality() {
  67         final var mock = mock(SystemLeafSetNode.class);
  68         doReturn(new NodeIdentifier(FOO)).when(mock).getIdentifier();
  69         doReturn(1).when(mock).size();
  70         doReturn(Builders.leafSetEntryBuilder()
  71             .withNodeIdentifier(new NodeWithValue<>(FOO, "abc"))
  72             .withValue("abc")
  73             .build()).when(mock).childByArg(new NodeWithValue<>(FOO, "abc"));
  74
  75         assertEquals(Builders.leafSetBuilder()
  76             .withNodeIdentifier(new NodeIdentifier(FOO))
  77             .withChild(Builders.leafSetEntryBuilder()
  78                 .withNodeIdentifier(new NodeWithValue<>(FOO, "abc"))
  79                 .withValue("abc")
  80                 .build())
  81             .build(), mock);
  82
  83         // Mismatched identifier
  84         assertNotEquals(Builders.leafSetBuilder()
  85             .withNodeIdentifier(new NodeIdentifier(BAR))
  86             .withChild(Builders.leafSetEntryBuilder()
  87                 .withNodeIdentifier(new NodeWithValue<>(BAR, "abc"))
  88                 .withValue("abc")
  89                 .build())
  90             .build(), mock);
  91
  92         // Mismatched child size
  93         assertNotEquals(Builders.leafSetBuilder()
  94             .withNodeIdentifier(new NodeIdentifier(FOO))
  95             .withChild(Builders.leafSetEntryBuilder()
  96                 .withNodeIdentifier(new NodeWithValue<>(FOO, "abc"))
  97                 .withValue("abc")
  98                 .build())
  99             .withChild(Builders.leafSetEntryBuilder()
 100                 .withNodeIdentifier(new NodeWithValue<>(FOO, "def"))
 101                 .withValue("def")
 102                 .build())
 103             .build(), mock);
 104
 105         // Mismatched child
 106         assertNotEquals(Builders.leafSetBuilder()
 107             .withNodeIdentifier(new NodeIdentifier(FOO))
 108             .withChild(Builders.leafSetEntryBuilder()
 109                 .withNodeIdentifier(new NodeWithValue<>(FOO, "def"))
 110                 .withValue("def")
 111                 .build())
 112             .build(), mock);
 113     }
 114
 115     @Test
 116     public void testUserLeafSetNodeEquality() {
 117         final var mock = mock(UserLeafSetNode.class);
 118         doReturn(new NodeIdentifier(FOO)).when(mock).getIdentifier();
 119         doReturn(List.of(
 120             Builders.leafSetEntryBuilder()
 121                 .withNodeIdentifier(new NodeWithValue<>(FOO, "abc"))
 122                 .withValue("abc")
 123                 .build(),
 124             Builders.leafSetEntryBuilder()
 125                 .withNodeIdentifier(new NodeWithValue<>(FOO, "def"))
 126                 .withValue("def")
 127                 .build())).when(mock).body();
 128
 129         assertEquals(Builders.orderedLeafSetBuilder()
 130             .withNodeIdentifier(new NodeIdentifier(FOO))
 131             .withChild(Builders.leafSetEntryBuilder()
 132                 .withNodeIdentifier(new NodeWithValue<>(FOO, "abc"))
 133                 .withValue("abc")
 134                 .build())
 135             .withChild(Builders.leafSetEntryBuilder()
 136                 .withNodeIdentifier(new NodeWithValue<>(FOO, "def"))
 137                 .withValue("def")
 138                 .build())
 139             .build(), mock);
 140
 141         // Mismatched identifier
 142         assertNotEquals(Builders.orderedLeafSetBuilder()
 143             .withNodeIdentifier(new NodeIdentifier(BAR))
 144             .withChild(Builders.leafSetEntryBuilder()
 145                 .withNodeIdentifier(new NodeWithValue<>(BAR, "abc"))
 146                 .withValue("abc")
 147                 .build())
 148             .withChild(Builders.leafSetEntryBuilder()
 149                 .withNodeIdentifier(new NodeWithValue<>(BAR, "def"))
 150                 .withValue("def")
 151                 .build())
 152             .build(), mock);
 153
 154         // Mismatched child order
 155         assertNotEquals(Builders.orderedLeafSetBuilder()
 156             .withNodeIdentifier(new NodeIdentifier(FOO))
 157             .withChild(Builders.leafSetEntryBuilder()
 158                 .withNodeIdentifier(new NodeWithValue<>(FOO, "def"))
 159                 .withValue("def")
 160                 .build())
 161             .withChild(Builders.leafSetEntryBuilder()
 162                 .withNodeIdentifier(new NodeWithValue<>(FOO, "abc"))
 163                 .withValue("abc")
 164                 .build())
 165             .build(), mock);
 166     }
 167 }