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