2 * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
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
8 package org.opendaylight.mdsal.binding.dom.adapter;
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;
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;
59 public class LeafDefaultValueTest extends AbstractDataBrokerTest {
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);
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);
79 private static final InstanceIdentifier<DecimalContainer> DECIMAL_NODE_PATH
80 = InstanceIdentifier.create(DecimalContainer.class);
82 private static final InstanceIdentifier<StringContainer> STRING_NODE_PATH
83 = InstanceIdentifier.create(StringContainer.class);
85 private static final InstanceIdentifier<BooleanContainer> BOOLEAN_NODE_PATH
86 = InstanceIdentifier.create(BooleanContainer.class);
88 private static final InstanceIdentifier<EnumContainer> ENUM_NODE_PATH
89 = InstanceIdentifier.create(EnumContainer.class);
91 private static final InstanceIdentifier<BitsContainer> BITS_NODE_PATH
92 = InstanceIdentifier.create(BitsContainer.class);
94 private static final InstanceIdentifier<BinaryContainer> BINARY_NODE_PATH
95 = InstanceIdentifier.create(BinaryContainer.class);
97 private static final InstanceIdentifier<IdentityrefContainer> IDENTITYREF_NODE_PATH
98 = InstanceIdentifier.create(IdentityrefContainer.class);
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();
106 final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
107 final Optional<TinyIntContainer> tinyIntContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
108 TINY_INT_NODE_PATH).get();
110 assertTrue(tinyIntContainerNode.isPresent());
112 TinyIntContainer tinyIntContainer = tinyIntContainerNode.orElseThrow();
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());
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();
127 final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
128 final Optional<SmallIntContainer> smallIntContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
129 SMALL_INT_NODE_PATH).get();
131 assertTrue(smallIntContainerNode.isPresent());
133 SmallIntContainer smallIntContainer = smallIntContainerNode.orElseThrow();
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());
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();
148 final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
149 final Optional<NormalIntContainer> normalIntContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
150 NORMAL_INT_NODE_PATH).get();
152 assertTrue(normalIntContainerNode.isPresent());
154 NormalIntContainer normalIntContainer = normalIntContainerNode.orElseThrow();
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());
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();
169 final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
170 final Optional<BigIntContainer> bigIntContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
171 BIG_INT_NODE_PATH).get();
173 assertTrue(bigIntContainerNode.isPresent());
175 BigIntContainer bigIntContainer = bigIntContainerNode.orElseThrow();
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());
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();
190 final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
191 final Optional<TinyUintContainer> tinyUintContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
192 TINY_UINT_NODE_PATH).get();
194 assertTrue(tinyUintContainerNode.isPresent());
196 TinyUintContainer tinyUintContainer = tinyUintContainerNode.orElseThrow();
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());
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();
211 final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
212 final Optional<SmallUintContainer> smallUintContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
213 SMALL_UINT_NODE_PATH).get();
215 assertTrue(smallUintContainerNode.isPresent());
217 SmallUintContainer smallUintContainer = smallUintContainerNode.orElseThrow();
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());
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();
232 final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
233 final Optional<NormalUintContainer> normalUintContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
234 NORMAL_UINT_NODE_PATH).get();
236 assertTrue(normalUintContainerNode.isPresent());
238 NormalUintContainer normalUintContainer = normalUintContainerNode.orElseThrow();
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());
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();
253 final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
254 final Optional<BigUintContainer> bigUintContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
255 BIG_UINT_NODE_PATH).get();
257 assertTrue(bigUintContainerNode.isPresent());
259 BigUintContainer bigUintContainer = bigUintContainerNode.orElseThrow();
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());
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();
274 final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
275 final Optional<DecimalContainer> decimalContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
276 DECIMAL_NODE_PATH).get();
278 assertTrue(decimalContainerNode.isPresent());
280 DecimalContainer decimalCont = decimalContainerNode.orElseThrow();
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());
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();
295 final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
296 final Optional<StringContainer> stringContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
297 STRING_NODE_PATH).get();
299 assertTrue(stringContainerNode.isPresent());
301 StringContainer stringCont = stringContainerNode.orElseThrow();
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());
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();
316 final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
317 final Optional<BooleanContainer> booleanContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
318 BOOLEAN_NODE_PATH).get();
320 assertTrue(booleanContainerNode.isPresent());
322 BooleanContainer boolCont = booleanContainerNode.orElseThrow();
323 assertTrue(boolCont.getBooleanLeaf());
324 assertNull(boolCont.getBooleanLeaf2());
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();
333 final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
334 final Optional<EnumContainer> enumContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
335 ENUM_NODE_PATH).get();
337 assertTrue(enumContainerNode.isPresent());
339 EnumContainer enumCont = enumContainerNode.orElseThrow();
340 assertEquals("Second", enumCont.getEnumLeaf().name());
341 assertEquals(2, enumCont.getEnumLeaf().getIntValue());
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();
350 final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
351 final Optional<BitsContainer> bitsContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
352 BITS_NODE_PATH).get();
354 assertTrue(bitsContainerNode.isPresent());
356 BitsContainer bitsCont = bitsContainerNode.orElseThrow();
357 assertFalse(bitsCont.getBitsLeaf().getBitZero());
358 assertTrue(bitsCont.getBitsLeaf().getBitOne());
359 assertFalse(bitsCont.getBitsLeaf().getBitTwo());
360 assertNull(bitsCont.getBitsLeaf2());
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();
369 final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
370 final Optional<BinaryContainer> binaryContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
371 BINARY_NODE_PATH).get();
373 assertTrue(binaryContainerNode.isPresent());
375 BinaryContainer binCont = binaryContainerNode.orElseThrow();
376 byte [] expectedBytes = {104, 101, 108, 108, 111};
377 byte [] actualBytes = binCont.getBinaryLeaf();
379 assertTrue(Arrays.equals(expectedBytes, actualBytes));
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();
388 final ReadTransaction readTx = getDataBroker().newReadOnlyTransaction();
389 final Optional<IdentityrefContainer> identityrefContainerNode = readTx.read(LogicalDatastoreType.OPERATIONAL,
390 IDENTITYREF_NODE_PATH).get();
392 assertTrue(identityrefContainerNode.isPresent());
394 IdentityrefContainer idrefCont = identityrefContainerNode.orElseThrow();
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());