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