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