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