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