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

   1 /*
   2  * Copyright (c) 2013 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.impl.schema.nodes;
   9
  10 import static org.junit.jupiter.api.Assertions.assertEquals;
  11 import static org.junit.jupiter.api.Assertions.assertNotEquals;
  12
  13 import org.junit.jupiter.api.Test;
  14 import org.opendaylight.yangtools.yang.common.QName;
  15 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
  16
  17 class AbstractImmutableNormalizedValueAttrNodeTest {
  18     private record TestValue(int value) {
  19         // Simple enough
  20     }
  21
  22     private static final QName ROOT_QNAME = QName.create("urn:test", "2014-03-13", "root");
  23     private static final QName LEAF_QNAME = QName.create(ROOT_QNAME, "my-leaf");
  24     private static final QName SAME_LEAF_QNAME = QName.create(ROOT_QNAME, "my-leaf");
  25     private static final QName OTHER_LEAF_QNAME = QName.create(ROOT_QNAME, "my-other-leaf");
  26
  27     @Test
  28     // This test is based on using different references; we're testing equals()
  29     @SuppressWarnings({"RedundantStringConstructorCall", "EqualsWithItself"})
  30     void equalsByteTest() {
  31         final var value = "test".getBytes();
  32         final var equalValue = "test".getBytes();
  33
  34         final var leafNode = ImmutableNodes.leafNode(LEAF_QNAME, value);
  35         final var equalLeafNode = ImmutableNodes.leafNode(SAME_LEAF_QNAME, equalValue);
  36
  37         assertEquals(leafNode, leafNode);
  38         assertEquals(leafNode, equalLeafNode);
  39         assertEquals(equalLeafNode, leafNode);
  40
  41         final var value2 = new TestValue[] { new TestValue(1), new TestValue(2) };
  42         final var equalValue2 = new TestValue[] { new TestValue(1), new TestValue(2) };
  43
  44         final var leafNode2 = ImmutableNodes.leafNode(LEAF_QNAME, value2);
  45         final var equalLeafNode2 = ImmutableNodes.leafNode(SAME_LEAF_QNAME, equalValue2);
  46
  47         assertEquals(leafNode2, leafNode2);
  48         assertEquals(leafNode2, equalLeafNode2);
  49         assertEquals(equalLeafNode2, leafNode2);
  50
  51         final var value3 = new byte[][] { "test".getBytes(), "test2".getBytes() };
  52         final var equalValue3 = new byte[][] { "test".getBytes(), "test2".getBytes() };
  53
  54         final var leafNode3 = ImmutableNodes.leafNode(LEAF_QNAME,
  55                 value3);
  56         final var equalLeafNode3 = ImmutableNodes.leafNode(SAME_LEAF_QNAME, equalValue3);
  57
  58         assertEquals(leafNode3, leafNode3);
  59         assertEquals(leafNode3, equalLeafNode3);
  60         assertEquals(equalLeafNode3, leafNode3);
  61
  62         final var value4 = new TestValue[][] {
  63             new TestValue[] { new TestValue(1), new TestValue(2) },
  64             new TestValue[] { new TestValue(3), new TestValue(4) },
  65         };
  66         final var equalValue4 = new TestValue[][] {
  67             new TestValue[] { new TestValue(1), new TestValue(2) },
  68             new TestValue[] { new TestValue(3), new TestValue(4) },
  69         };
  70
  71         final var leafNode4 = ImmutableNodes.leafNode(LEAF_QNAME,value4);
  72         final var equalLeafNode4 = ImmutableNodes.leafNode(SAME_LEAF_QNAME, equalValue4);
  73
  74         assertEquals(leafNode4, leafNode4);
  75         assertEquals(leafNode4, equalLeafNode4);
  76         assertEquals(equalLeafNode4, leafNode4);
  77
  78         final var value6 = new TestValue(1);
  79         final var equalValue6 = new TestValue(1);
  80
  81         final var leafNode6 = ImmutableNodes.leafNode(LEAF_QNAME, value6);
  82         final var equalLeafNode6 = ImmutableNodes.leafNode(SAME_LEAF_QNAME, equalValue6);
  83
  84         assertEquals(leafNode6, leafNode6);
  85         assertEquals(leafNode6, equalLeafNode6);
  86         assertEquals(equalLeafNode6, leafNode6);
  87
  88         final var value5 = "test";
  89         final var equalValue5 = new String("test");
  90
  91         final var leafNode5 = ImmutableNodes.leafNode(LEAF_QNAME, value5);
  92         final var equalLeafNode5 = ImmutableNodes.leafNode(SAME_LEAF_QNAME, equalValue5);
  93
  94         assertEquals(leafNode5, leafNode5);
  95         assertEquals(leafNode5, equalLeafNode5);
  96         assertEquals(equalLeafNode5, leafNode5);
  97     }
  98
  99     @Test
 100     // We're testing equals()
 101     @SuppressWarnings({"ObjectEqualsNull", "EqualsBetweenInconvertibleTypes"})
 102     void notEqualByteTest() {
 103
 104         final var value = "test".getBytes();
 105         final var equalValue = "test".getBytes();
 106
 107         final var leafNode = ImmutableNodes.leafNode(LEAF_QNAME, value);
 108         final var otherLeafNode = ImmutableNodes.leafNode(OTHER_LEAF_QNAME, equalValue);
 109
 110         assertNotEquals(null, leafNode);
 111         assertNotEquals(leafNode, new Object());
 112         assertNotEquals(leafNode, otherLeafNode);
 113         assertNotEquals(otherLeafNode, leafNode);
 114
 115         final var value1 = "test".getBytes();
 116         final var otherValue1 = "test1".getBytes();
 117
 118         final var leafNode1 = ImmutableNodes.leafNode(LEAF_QNAME, value1);
 119         final var otherLeafNode1 = ImmutableNodes.leafNode(SAME_LEAF_QNAME, otherValue1);
 120
 121         assertNotEquals(leafNode1, otherLeafNode1);
 122         assertNotEquals(otherLeafNode1, leafNode1);
 123
 124         final var value2 = new TestValue[] { new TestValue(1), new TestValue(1) };
 125         final var otherValue2 = new TestValue[] { new TestValue(1), new TestValue(2) };
 126
 127         final var leafNode2 = ImmutableNodes.leafNode(LEAF_QNAME, value2);
 128         final var otherLeafNode2 = ImmutableNodes.leafNode(SAME_LEAF_QNAME, otherValue2);
 129
 130         assertNotEquals(leafNode2, otherLeafNode2);
 131         assertNotEquals(otherLeafNode2, leafNode2);
 132
 133         final var value3 = new byte[][] { "test".getBytes(), "test2".getBytes() };
 134         final var otherValue3 = new byte[][] { "test".getBytes(), "test3".getBytes() };
 135
 136         final var leafNode3 = ImmutableNodes.leafNode(LEAF_QNAME, value3);
 137         final var otherLeafNode3 = ImmutableNodes.leafNode(SAME_LEAF_QNAME, otherValue3);
 138
 139         assertNotEquals(leafNode3, otherLeafNode3);
 140         assertNotEquals(otherLeafNode3, leafNode3);
 141
 142         final var value4 = new TestValue[][] {
 143             new TestValue[] { new TestValue(1), new TestValue(2) },
 144             new TestValue[] { new TestValue(3), new TestValue(4) },
 145         };
 146         final var otherValue4 = new TestValue[][] {
 147             new TestValue[] { new TestValue(1), new TestValue(2) },
 148             new TestValue[] { new TestValue(3), new TestValue(5) },
 149         };
 150
 151         final var leafNode4 = ImmutableNodes.leafNode(LEAF_QNAME, value4);
 152         final var otherLeafNode4 = ImmutableNodes.leafNode(SAME_LEAF_QNAME, otherValue4);
 153
 154         assertNotEquals(leafNode4, otherLeafNode4);
 155         assertNotEquals(otherLeafNode4, leafNode4);
 156
 157         final var value6 = new TestValue(1);
 158         final var otherValue6 = new TestValue(2);
 159
 160         final var leafNode6 = ImmutableNodes.leafNode(LEAF_QNAME, value6);
 161         final var otherLeafNode6 = ImmutableNodes.leafNode(SAME_LEAF_QNAME, otherValue6);
 162
 163         assertNotEquals(leafNode6, otherLeafNode6);
 164         assertNotEquals(otherLeafNode6, leafNode6);
 165
 166         final var value5 = "test";
 167         final var otherValue5 = "test2";
 168
 169         final var leafNode5 = ImmutableNodes.leafNode(LEAF_QNAME, value5);
 170         final var otherLeafNode5 = ImmutableNodes.leafNode(SAME_LEAF_QNAME, otherValue5);
 171
 172         assertNotEquals(leafNode5, otherLeafNode5);
 173         assertNotEquals(otherLeafNode5, leafNode5);
 174         assertNotEquals(leafNode5, leafNode);
 175         assertNotEquals(leafNode5, leafNode1);
 176         assertNotEquals(leafNode5, leafNode2);
 177         assertNotEquals(leafNode5, leafNode3);
 178         assertNotEquals(leafNode5, leafNode4);
 179         assertNotEquals(leafNode5, leafNode6);
 180         assertNotEquals(leafNode, leafNode5);
 181         assertNotEquals(leafNode1, leafNode5);
 182         assertNotEquals(leafNode2, leafNode5);
 183         assertNotEquals(leafNode3, leafNode5);
 184         assertNotEquals(leafNode4, leafNode5);
 185         assertNotEquals(leafNode6, leafNode5);
 186
 187         final var byteValue = new byte[] { 1, 1 };
 188
 189         final var byteLeafNode = ImmutableNodes.leafNode(SAME_LEAF_QNAME, byteValue);
 190         assertNotEquals(byteLeafNode, leafNode2);
 191         assertNotEquals(leafNode2, byteLeafNode);
 192     }
 193
 194     @Test
 195     // We're testing equals()
 196     @SuppressWarnings({"EqualsWithItself", "EqualsBetweenInconvertibleTypes"})
 197     void equalsOtherTypesTest() {
 198
 199         final var valueChar = "test".toCharArray();
 200         final var equalValueChar = "test".toCharArray();
 201
 202         final var leafNodeChar = ImmutableNodes.leafNode(LEAF_QNAME, valueChar);
 203         final var equalLeafNodeChar = ImmutableNodes.leafNode(SAME_LEAF_QNAME, equalValueChar);
 204
 205         assertEquals(leafNodeChar, leafNodeChar);
 206         assertEquals(leafNodeChar, equalLeafNodeChar);
 207         assertEquals(equalLeafNodeChar, leafNodeChar);
 208
 209         final var value = new boolean[] { true, false };
 210         final var equalValue = new boolean[] { true, false };
 211
 212         final var leafNode = ImmutableNodes.leafNode(LEAF_QNAME, value);
 213         final var equalLeafNode = ImmutableNodes.leafNode(SAME_LEAF_QNAME, equalValue);
 214
 215         assertEquals(leafNode, leafNode);
 216         assertEquals(leafNode, equalLeafNode);
 217         assertEquals(equalLeafNode, leafNode);
 218
 219         final var value2 = new int[] { 1, 2 };
 220         final var equalValue2 = new int[] { 1, 2 };
 221
 222         final var leafNode2 = ImmutableNodes.leafNode(LEAF_QNAME, value2);
 223         final var equalLeafNode2 = ImmutableNodes.leafNode(SAME_LEAF_QNAME, equalValue2);
 224
 225         assertEquals(leafNode2, leafNode2);
 226         assertEquals(leafNode2, equalLeafNode2);
 227         assertEquals(equalLeafNode2, leafNode2);
 228
 229         final var value3 = new short[] { 1, 2 };
 230         final var equalValue3 = new short[] { 1, 2 };
 231
 232         final var leafNode3 = ImmutableNodes.leafNode(LEAF_QNAME, value3);
 233         final var equalLeafNode3 = ImmutableNodes.leafNode(SAME_LEAF_QNAME, equalValue3);
 234
 235         assertEquals(leafNode3, leafNode3);
 236         assertEquals(leafNode3, equalLeafNode3);
 237         assertEquals(equalLeafNode3, leafNode3);
 238
 239         final var value4 = new long[] { 1, 2 };
 240         final var equalValue4 = new long[] { 1, 2 };
 241
 242         final var leafNode4 = ImmutableNodes.leafNode(LEAF_QNAME, value4);
 243         final var equalLeafNode4 = ImmutableNodes.leafNode(SAME_LEAF_QNAME, equalValue4);
 244
 245         assertEquals(leafNode4, leafNode4);
 246         assertEquals(leafNode4, equalLeafNode4);
 247         assertEquals(equalLeafNode4, leafNode4);
 248
 249         final var value6 = new double[] { 1, 2 };
 250         final var equalValue6 = new double[] { 1, 2 };
 251
 252         final var leafNode6 = ImmutableNodes.leafNode(LEAF_QNAME, value6);
 253         final var equalLeafNode6 = ImmutableNodes.leafNode(SAME_LEAF_QNAME, equalValue6);
 254
 255         assertEquals(leafNode6, leafNode6);
 256         assertEquals(leafNode6, equalLeafNode6);
 257         assertEquals(equalLeafNode6, leafNode6);
 258
 259         final var value5 = new float[] { 1, 2 };
 260         final var equalValue5 = new float[] { 1, 2 };
 261
 262         final var leafNode5 = ImmutableNodes.leafNode(LEAF_QNAME, value5);
 263         final var equalLeafNode5 = ImmutableNodes.leafNode(SAME_LEAF_QNAME, equalValue5);
 264
 265         assertEquals(leafNode5, leafNode5);
 266         assertEquals(leafNode5, equalLeafNode5);
 267         assertEquals(equalLeafNode5, leafNode5);
 268
 269         assertNotEquals(leafNode, leafNode5);
 270         assertNotEquals(leafNode2, leafNode5);
 271         assertNotEquals(leafNode3, leafNode5);
 272         assertNotEquals(leafNode4, leafNode5);
 273         assertNotEquals(leafNodeChar, leafNode5);
 274         assertNotEquals(leafNode6, leafNode5);
 275
 276         assertNotEquals(leafNode5, leafNode);
 277         assertNotEquals(leafNode5, leafNode2);
 278         assertNotEquals(leafNode5, leafNode3);
 279         assertNotEquals(leafNode5, leafNode4);
 280         assertNotEquals(leafNode5, leafNodeChar);
 281         assertNotEquals(leafNode5, leafNode6);
 282     }
 283 }