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