binding/mdsal-binding-dom-adapter/src/test/java/org/opendaylight/mdsal/binding/dom/adapter/test/LeafDefaultValueTest.java

   1 /*
   2  * Copyright (c) 2015 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
   9 package org.opendaylight.mdsal.binding.dom.adapter.test;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import static org.junit.Assert.assertFalse;
  13 import static org.junit.Assert.assertNull;
  14 import static org.junit.Assert.assertTrue;
  15
  16 import java.util.Arrays;
  17 import java.util.Optional;
  18 import java.util.concurrent.ExecutionException;
  19 import org.junit.Test;
  20 import org.opendaylight.mdsal.binding.api.ReadTransaction;
  21 import org.opendaylight.mdsal.binding.api.WriteTransaction;
  22 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns._default.value.test.norev.BigIntContainer;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns._default.value.test.norev.BigIntContainerBuilder;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns._default.value.test.norev.BigUintContainer;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns._default.value.test.norev.BigUintContainerBuilder;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns._default.value.test.norev.BinaryContainer;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns._default.value.test.norev.BinaryContainerBuilder;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns._default.value.test.norev.BitsContainer;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns._default.value.test.norev.BitsContainerBuilder;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns._default.value.test.norev.BooleanContainer;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns._default.value.test.norev.BooleanContainerBuilder;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns._default.value.test.norev.DecimalContainer;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns._default.value.test.norev.DecimalContainerBuilder;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns._default.value.test.norev.EnumContainer;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns._default.value.test.norev.EnumContainerBuilder;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns._default.value.test.norev.IdentityrefContainer;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns._default.value.test.norev.IdentityrefContainerBuilder;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns._default.value.test.norev.NormalIntContainer;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns._default.value.test.norev.NormalIntContainerBuilder;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns._default.value.test.norev.NormalUintContainer;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns._default.value.test.norev.NormalUintContainerBuilder;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns._default.value.test.norev.SmallIntContainer;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns._default.value.test.norev.SmallIntContainerBuilder;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns._default.value.test.norev.SmallUintContainer;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns._default.value.test.norev.SmallUintContainerBuilder;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns._default.value.test.norev.StringContainer;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns._default.value.test.norev.StringContainerBuilder;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns._default.value.test.norev.TinyIntContainer;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns._default.value.test.norev.TinyIntContainerBuilder;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns._default.value.test.norev.TinyUintContainer;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns._default.value.test.norev.TinyUintContainerBuilder;
  53 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  54
  55 public class LeafDefaultValueTest extends AbstractDataBrokerTest {
  56
  57     private static final InstanceIdentifier<TinyIntContainer> TINY_INT_NODE_PATH
  58             = InstanceIdentifier.create(TinyIntContainer.class);
  59     private static final InstanceIdentifier<SmallIntContainer> SMALL_INT_NODE_PATH
  60             = InstanceIdentifier.create(SmallIntContainer.class);
  61     private static final InstanceIdentifier<NormalIntContainer> NORMAL_INT_NODE_PATH
  62             = InstanceIdentifier.create(NormalIntContainer.class);
  63     private static final InstanceIdentifier<BigIntContainer> BIG_INT_NODE_PATH
  64             = InstanceIdentifier.create(BigIntContainer.class);
  65
  66     private static final InstanceIdentifier<TinyUintContainer> TINY_UINT_NODE_PATH
  67             = InstanceIdentifier.create(TinyUintContainer.class);
  68     private static final InstanceIdentifier<SmallUintContainer> SMALL_UINT_NODE_PATH
  69             = InstanceIdentifier.create(SmallUintContainer.class);
  70     private static final InstanceIdentifier<NormalUintContainer> NORMAL_UINT_NODE_PATH
  71             = InstanceIdentifier.create(NormalUintContainer.class);
  72     private static final InstanceIdentifier<BigUintContainer> BIG_UINT_NODE_PATH
  73             = InstanceIdentifier.create(BigUintContainer.class);
  74
  75     private static final InstanceIdentifier<DecimalContainer> DECIMAL_NODE_PATH
  76             = InstanceIdentifier.create(DecimalContainer.class);
  77
  78     private static final InstanceIdentifier<StringContainer> STRING_NODE_PATH
  79             = InstanceIdentifier.create(StringContainer.class);
  80
  81     private static final InstanceIdentifier<BooleanContainer> BOOLEAN_NODE_PATH
  82             = InstanceIdentifier.create(BooleanContainer.class);
  83
  84     private static final InstanceIdentifier<EnumContainer> ENUM_NODE_PATH
  85             = InstanceIdentifier.create(EnumContainer.class);
  86
  87     private static final InstanceIdentifier<BitsContainer> BITS_NODE_PATH
  88             = InstanceIdentifier.create(BitsContainer.class);
  89
  90     private static final InstanceIdentifier<BinaryContainer> BINARY_NODE_PATH
  91             = InstanceIdentifier.create(BinaryContainer.class);
  92
  93     private static final InstanceIdentifier<IdentityrefContainer> IDENTITYREF_NODE_PATH
  94             = InstanceIdentifier.create(IdentityrefContainer.class);
  95
  96     @Test
  97     public void testTinyIntDefaultValue() throws ExecutionException, InterruptedException {
  98         final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
  99         writeTx.put(LogicalDatastoreType.OPERATIONAL, TINY_INT_NODE_PATH, new TinyIntContainerBuilder().build());
 100         writeTx.commit().get();
 101
 102         final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
 103         final Optional<TinyIntContainer> tinyIntContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
 104                 TINY_INT_NODE_PATH).get();
 105
 106         assertTrue(tinyIntContainerNode.isPresent());
 107
 108         TinyIntContainer tinyIntContainer = tinyIntContainerNode.get();
 109         assertEquals(-18, tinyIntContainer.getTinyIntLeaf().getValue().byteValue());
 110         assertEquals(-18, tinyIntContainer.getTinyIntLeaf2().getValue().byteValue());
 111         assertEquals(-15, tinyIntContainer.getTinyIntLeaf3().getValue().byteValue());
 112         assertEquals(-18, tinyIntContainer.getTinyIntLeaf4().getValue().byteValue());
 113         assertEquals(-120, tinyIntContainer.getTinyIntLeaf5().byteValue());
 114         assertEquals(null, tinyIntContainer.getTinyIntLeaf6());
 115     }
 116
 117     @Test
 118     public void testSmallIntDefaultValue() throws ExecutionException, InterruptedException {
 119         final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
 120         writeTx.put(LogicalDatastoreType.OPERATIONAL, SMALL_INT_NODE_PATH, new SmallIntContainerBuilder().build());
 121         writeTx.commit().get();
 122
 123         final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
 124         final Optional<SmallIntContainer> smallIntContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
 125                 SMALL_INT_NODE_PATH).get();
 126
 127         assertTrue(smallIntContainerNode.isPresent());
 128
 129         SmallIntContainer smallIntContainer = smallIntContainerNode.get();
 130         assertEquals(-20000, smallIntContainer.getSmallIntLeaf().getValue().shortValue());
 131         assertEquals(-20000, smallIntContainer.getSmallIntLeaf2().getValue().shortValue());
 132         assertEquals(-15000, smallIntContainer.getSmallIntLeaf3().getValue().shortValue());
 133         assertEquals(-20000, smallIntContainer.getSmallIntLeaf4().getValue().shortValue());
 134         assertEquals(-5000, smallIntContainer.getSmallIntLeaf5().shortValue());
 135         assertEquals(null, smallIntContainer.getSmallIntLeaf6());
 136     }
 137
 138     @Test
 139     public void testNormalIntDefaultValue() throws ExecutionException, InterruptedException {
 140         final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
 141         writeTx.put(LogicalDatastoreType.OPERATIONAL, NORMAL_INT_NODE_PATH, new NormalIntContainerBuilder().build());
 142         writeTx.commit().get();
 143
 144         final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
 145         final Optional<NormalIntContainer> normalIntContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
 146                 NORMAL_INT_NODE_PATH).get();
 147
 148         assertTrue(normalIntContainerNode.isPresent());
 149
 150         NormalIntContainer normalIntContainer = normalIntContainerNode.get();
 151         assertEquals(-200000, normalIntContainer.getNormalIntLeaf().getValue().intValue());
 152         assertEquals(-200000, normalIntContainer.getNormalIntLeaf2().getValue().intValue());
 153         assertEquals(-130000, normalIntContainer.getNormalIntLeaf3().getValue().intValue());
 154         assertEquals(-200000, normalIntContainer.getNormalIntLeaf4().getValue().intValue());
 155         assertEquals(-95000, normalIntContainer.getNormalIntLeaf5().intValue());
 156         assertEquals(null, normalIntContainer.getNormalIntLeaf6());
 157     }
 158
 159     @Test
 160     public void testBigIntDefaultValue() throws ExecutionException, InterruptedException {
 161         final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
 162         writeTx.put(LogicalDatastoreType.OPERATIONAL, BIG_INT_NODE_PATH, new BigIntContainerBuilder().build());
 163         writeTx.commit().get();
 164
 165         final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
 166         final Optional<BigIntContainer> bigIntContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
 167                 BIG_INT_NODE_PATH).get();
 168
 169         assertTrue(bigIntContainerNode.isPresent());
 170
 171         BigIntContainer bigIntContainer = bigIntContainerNode.get();
 172         assertEquals(-3300000000L, bigIntContainer.getBigIntLeaf().getValue().longValue());
 173         assertEquals(-3300000000L, bigIntContainer.getBigIntLeaf2().getValue().longValue());
 174         assertEquals(-2800000000L, bigIntContainer.getBigIntLeaf3().getValue().longValue());
 175         assertEquals(-3300000000L, bigIntContainer.getBigIntLeaf4().getValue().longValue());
 176         assertEquals(-2500000000L, bigIntContainer.getBigIntLeaf5().longValue());
 177         assertEquals(null, bigIntContainer.getBigIntLeaf6());
 178     }
 179
 180     @Test
 181     public void testTinyUintDefaultValue() throws ExecutionException, InterruptedException {
 182         final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
 183         writeTx.put(LogicalDatastoreType.OPERATIONAL, TINY_UINT_NODE_PATH, new TinyUintContainerBuilder().build());
 184         writeTx.commit().get();
 185
 186         final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
 187         final Optional<TinyUintContainer> tinyUintContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
 188                 TINY_UINT_NODE_PATH).get();
 189
 190         assertTrue(tinyUintContainerNode.isPresent());
 191
 192         TinyUintContainer tinyUintContainer = tinyUintContainerNode.get();
 193         assertEquals(150, tinyUintContainer.getTinyUintLeaf().getValue().shortValue());
 194         assertEquals(150, tinyUintContainer.getTinyUintLeaf2().getValue().shortValue());
 195         assertEquals(170, tinyUintContainer.getTinyUintLeaf3().getValue().shortValue());
 196         assertEquals(150, tinyUintContainer.getTinyUintLeaf4().getValue().shortValue());
 197         assertEquals(155, tinyUintContainer.getTinyUintLeaf5().shortValue());
 198         assertEquals(null, tinyUintContainer.getTinyUintLeaf6());
 199     }
 200
 201     @Test
 202     public void testSmallUintDefaultValue() throws ExecutionException, InterruptedException {
 203         final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
 204         writeTx.put(LogicalDatastoreType.OPERATIONAL, SMALL_UINT_NODE_PATH, new SmallUintContainerBuilder().build());
 205         writeTx.commit().get();
 206
 207         final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
 208         final Optional<SmallUintContainer> smallUintContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
 209                 SMALL_UINT_NODE_PATH).get();
 210
 211         assertTrue(smallUintContainerNode.isPresent());
 212
 213         SmallUintContainer smallUintContainer = smallUintContainerNode.get();
 214         assertEquals(35000, smallUintContainer.getSmallUintLeaf().getValue().intValue());
 215         assertEquals(35000, smallUintContainer.getSmallUintLeaf2().getValue().intValue());
 216         assertEquals(45000, smallUintContainer.getSmallUintLeaf3().getValue().intValue());
 217         assertEquals(35000, smallUintContainer.getSmallUintLeaf4().getValue().intValue());
 218         assertEquals(62000, smallUintContainer.getSmallUintLeaf5().intValue());
 219         assertEquals(null, smallUintContainer.getSmallUintLeaf6());
 220     }
 221
 222     @Test
 223     public void testNormalUintDefaultValue() throws ExecutionException, InterruptedException {
 224         final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
 225         writeTx.put(LogicalDatastoreType.OPERATIONAL, NORMAL_UINT_NODE_PATH, new NormalUintContainerBuilder().build());
 226         writeTx.commit().get();
 227
 228         final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
 229         final Optional<NormalUintContainer> normalUintContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
 230                 NORMAL_UINT_NODE_PATH).get();
 231
 232         assertTrue(normalUintContainerNode.isPresent());
 233
 234         NormalUintContainer normalUintContainer = normalUintContainerNode.get();
 235         assertEquals(100000, normalUintContainer.getNormalUintLeaf().getValue().longValue());
 236         assertEquals(100000, normalUintContainer.getNormalUintLeaf2().getValue().longValue());
 237         assertEquals(250000, normalUintContainer.getNormalUintLeaf3().getValue().longValue());
 238         assertEquals(100000, normalUintContainer.getNormalUintLeaf4().getValue().longValue());
 239         assertEquals(150000, normalUintContainer.getNormalUintLeaf5().longValue());
 240         assertEquals(null, normalUintContainer.getNormalUintLeaf6());
 241     }
 242
 243     @Test
 244     public void testBigUintDefaultValue() throws ExecutionException, InterruptedException {
 245         final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
 246         writeTx.put(LogicalDatastoreType.OPERATIONAL, BIG_UINT_NODE_PATH, new BigUintContainerBuilder().build());
 247         writeTx.commit().get();
 248
 249         final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
 250         final Optional<BigUintContainer> bigUintContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
 251                 BIG_UINT_NODE_PATH).get();
 252
 253         assertTrue(bigUintContainerNode.isPresent());
 254
 255         BigUintContainer bigUintContainer = bigUintContainerNode.get();
 256         assertEquals(5000000000L, bigUintContainer.getBigUintLeaf().getValue().longValue());
 257         assertEquals(5000000000L, bigUintContainer.getBigUintLeaf2().getValue().longValue());
 258         assertEquals(5800000000L, bigUintContainer.getBigUintLeaf3().getValue().longValue());
 259         assertEquals(5000000000L, bigUintContainer.getBigUintLeaf4().getValue().longValue());
 260         assertEquals(6500000000L, bigUintContainer.getBigUintLeaf5().longValue());
 261         assertEquals(null, bigUintContainer.getBigUintLeaf6());
 262     }
 263
 264     @Test
 265     public void testDecimalDefaultValue() throws ExecutionException, InterruptedException {
 266         final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
 267         writeTx.put(LogicalDatastoreType.OPERATIONAL, DECIMAL_NODE_PATH, new DecimalContainerBuilder().build());
 268         writeTx.commit().get();
 269
 270         final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
 271         final Optional<DecimalContainer> decimalContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
 272                 DECIMAL_NODE_PATH).get();
 273
 274         assertTrue(decimalContainerNode.isPresent());
 275
 276         DecimalContainer decimalCont = decimalContainerNode.get();
 277         assertEquals(66.66, decimalCont.getDecimalLeaf().getValue().doubleValue(), 0.001);
 278         assertEquals(66.66, decimalCont.getDecimalLeaf2().getValue().doubleValue(), 0.001);
 279         assertEquals(99.99, decimalCont.getDecimalLeaf3().getValue().doubleValue(), 0.001);
 280         assertEquals(66.66, decimalCont.getDecimalLeaf4().getValue().doubleValue(), 0.001);
 281         assertEquals(120.55, decimalCont.getDecimalLeaf5().doubleValue(), 0.001);
 282         assertEquals(null, decimalCont.getDecimalLeaf6());
 283     }
 284
 285     @Test
 286     public void testStringDefaultValue() throws ExecutionException, InterruptedException {
 287         final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
 288         writeTx.put(LogicalDatastoreType.OPERATIONAL, STRING_NODE_PATH, new StringContainerBuilder().build());
 289         writeTx.commit().get();
 290
 291         final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
 292         final Optional<StringContainer> stringContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
 293                 STRING_NODE_PATH).get();
 294
 295         assertTrue(stringContainerNode.isPresent());
 296
 297         StringContainer stringCont = stringContainerNode.get();
 298         assertEquals("unspecified string", stringCont.getStringLeaf().getValue());
 299         assertEquals("unspecified string", stringCont.getStringLeaf2().getValue());
 300         assertEquals("unknown", stringCont.getStringLeaf3().getValue());
 301         assertEquals("unspecified string", stringCont.getStringLeaf4().getValue());
 302         assertEquals("whatever", stringCont.getStringLeaf5());
 303         assertNull(stringCont.getStringLeaf6());
 304     }
 305
 306     @Test
 307     public void testBooleanDefaultValue() throws ExecutionException, InterruptedException {
 308         final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
 309         writeTx.put(LogicalDatastoreType.OPERATIONAL, BOOLEAN_NODE_PATH, new BooleanContainerBuilder().build());
 310         writeTx.commit().get();
 311
 312         final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
 313         final Optional<BooleanContainer> booleanContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
 314                 BOOLEAN_NODE_PATH).get();
 315
 316         assertTrue(booleanContainerNode.isPresent());
 317
 318         BooleanContainer boolCont = booleanContainerNode.get();
 319         assertTrue(boolCont.isBooleanLeaf());
 320         assertNull(boolCont.isBooleanLeaf2());
 321     }
 322
 323     @Test
 324     public void testEnumerationDefaultValue() throws ExecutionException, InterruptedException {
 325         final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
 326         writeTx.put(LogicalDatastoreType.OPERATIONAL, ENUM_NODE_PATH, new EnumContainerBuilder().build());
 327         writeTx.commit().get();
 328
 329         final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
 330         final Optional<EnumContainer> enumContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
 331                 ENUM_NODE_PATH).get();
 332
 333         assertTrue(enumContainerNode.isPresent());
 334
 335         EnumContainer enumCont = enumContainerNode.get();
 336         assertEquals("Second", enumCont.getEnumLeaf().name());
 337         assertEquals(2, enumCont.getEnumLeaf().getIntValue());
 338     }
 339
 340     @Test
 341     public void testBitsDefaultValue() throws ExecutionException, InterruptedException {
 342         final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
 343         writeTx.put(LogicalDatastoreType.OPERATIONAL, BITS_NODE_PATH, new BitsContainerBuilder().build());
 344         writeTx.commit().get();
 345
 346         final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
 347         final Optional<BitsContainer> bitsContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
 348                 BITS_NODE_PATH).get();
 349
 350         assertTrue(bitsContainerNode.isPresent());
 351
 352         BitsContainer bitsCont = bitsContainerNode.get();
 353         assertFalse(bitsCont.getBitsLeaf().isBitZero());
 354         assertTrue(bitsCont.getBitsLeaf().isBitOne());
 355         assertFalse(bitsCont.getBitsLeaf().isBitTwo());
 356         assertNull(bitsCont.getBitsLeaf2());
 357     }
 358
 359     @Test
 360     public void testBinaryDefaultValue() throws ExecutionException, InterruptedException {
 361         final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
 362         writeTx.put(LogicalDatastoreType.OPERATIONAL, BINARY_NODE_PATH, new BinaryContainerBuilder().build());
 363         writeTx.commit().get();
 364
 365         final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
 366         final Optional<BinaryContainer> binaryContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
 367                 BINARY_NODE_PATH).get();
 368
 369         assertTrue(binaryContainerNode.isPresent());
 370
 371         BinaryContainer binCont = binaryContainerNode.get();
 372         byte [] expectedBytes = {104, 101, 108, 108, 111};
 373         byte [] actualBytes = binCont.getBinaryLeaf();
 374
 375         assertTrue(Arrays.equals(expectedBytes, actualBytes));
 376     }
 377
 378     @Test
 379     public void testIdentityrefDefaultValue() throws ExecutionException, InterruptedException {
 380         final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
 381         writeTx.put(LogicalDatastoreType.OPERATIONAL, IDENTITYREF_NODE_PATH, new IdentityrefContainerBuilder().build());
 382         writeTx.commit().get();
 383
 384         final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
 385         final Optional<IdentityrefContainer> identityrefContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
 386                 IDENTITYREF_NODE_PATH).get();
 387
 388         assertTrue(identityrefContainerNode.isPresent());
 389
 390         IdentityrefContainer idrefCont = identityrefContainerNode.get();
 391         assertNull(idrefCont.getIdentityrefLeaf());
 392         assertEquals("MyDerivedIdentity", idrefCont.getIdentityrefLeaf2().getSimpleName());
 393         assertEquals("MyDerivedIdentity", idrefCont.getIdentityrefLeaf3().getSimpleName());
 394         assertEquals("MyDerivedIdentity2", idrefCont.getIdentityrefLeaf4().getSimpleName());
 395         assertEquals("MyDerivedImportedIdentity", idrefCont.getIdentityrefLeaf5().getSimpleName());
 396         assertEquals("MyDerivedIdentity", idrefCont.getIdentityrefLeaf6().getSimpleName());
 397         assertNull(idrefCont.getIdentityrefLeaf7());
 398     }
 399 }