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