Method: testRemoveAllValuesOfTypedUnmappedProperty()

1: /**
2: * Copyright (C) 2016 Czech Technical University in Prague
3: *
4: * This program is free software: you can redistribute it and/or modify it under
5: * the terms of the GNU General Public License as published by the Free Software
6: * Foundation, either version 3 of the License, or (at your option) any
7: * later version.
8: *
9: * This program is distributed in the hope that it will be useful, but WITHOUT
10: * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11: * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
12: * details. You should have received a copy of the GNU General Public License
13: * along with this program. If not, see <http://www.gnu.org/licenses/>.
14: */
15: package cz.cvut.kbss.jopa.test.runner;
16:
17: import cz.cvut.kbss.jopa.model.annotations.Id;
18: import cz.cvut.kbss.jopa.model.annotations.OWLAnnotationProperty;
19: import cz.cvut.kbss.jopa.model.annotations.OWLDataProperty;
20: import cz.cvut.kbss.jopa.model.annotations.OWLObjectProperty;
21: import cz.cvut.kbss.jopa.test.*;
22: import cz.cvut.kbss.jopa.test.environment.DataAccessor;
23: import cz.cvut.kbss.jopa.test.environment.Generators;
24: import cz.cvut.kbss.jopa.test.environment.PersistenceFactory;
25: import cz.cvut.kbss.jopa.test.environment.TestEnvironmentUtils;
26: import cz.cvut.kbss.jopa.utils.EntityPropertiesUtils;
27: import org.junit.Ignore;
28: import org.junit.Test;
29: import org.slf4j.Logger;
30:
31: import java.lang.reflect.Field;
32: import java.net.URI;
33: import java.util.*;
34:
35: import static org.junit.Assert.*;
36:
37: public abstract class DeleteOperationsRunner extends BaseRunner {
38:
39: public DeleteOperationsRunner(Logger logger, PersistenceFactory persistenceFactory, DataAccessor dataAccessor) {
40: super(logger, persistenceFactory, dataAccessor);
41: }
42:
43: @Test
44: public void testRemoveSimple() {
45: this.em = getEntityManager("SimpleRemove", false);
46: persist(entityA);
47:
48: final OWLClassA a = em.find(OWLClassA.class, entityA.getUri());
49: assertNotNull(a);
50: em.getTransaction().begin();
51: em.remove(a);
52: em.getTransaction().commit();
53:
54: assertNull(em.find(OWLClassA.class, entityA.getUri()));
55: verifyIndividualWasRemoved(entityA.getUri());
56: }
57:
58: // TODO First we need to resolve referential integrity
59: @Ignore
60: @Test
61: public void testRemoveReference() {
62: this.em = getEntityManager("RemoveReference", false);
63: persist(entityD, entityA);
64:
65: final OWLClassA a = em.find(OWLClassA.class, entityA.getUri());
66: assertNotNull(a);
67: em.getTransaction().begin();
68: em.remove(a);
69: em.getTransaction().commit();
70:
71: final OWLClassD res = em.find(OWLClassD.class, entityD.getUri());
72: assertNotNull(res);
73: assertNull(em.find(OWLClassA.class, entityA.getUri()));
74: }
75:
76: @Test
77: public void testRemoveCascade() {
78: this.em = getEntityManager("RemoveCascade", false);
79: em.getTransaction().begin();
80: em.persist(entityG);
81: assertTrue(em.contains(entityG));
82: assertTrue(em.contains(entityH));
83: assertTrue(em.contains(entityA));
84: em.getTransaction().commit();
85:
86: em.getTransaction().begin();
87: final OWLClassG g = em.find(OWLClassG.class, entityG.getUri());
88: final OWLClassH h = em.find(OWLClassH.class, entityH.getUri());
89: final OWLClassA a = em.find(OWLClassA.class, entityA.getUri());
90: assertNotNull(g);
91: assertNotNull(h);
92: assertNotNull(a);
93: assertTrue(em.contains(g));
94: assertTrue(em.contains(h));
95: assertTrue(em.contains(a));
96: assertNotNull(g);
97: em.remove(g);
98: assertFalse(em.contains(g));
99: assertFalse(em.contains(h));
100: assertFalse(em.contains(a));
101: em.getTransaction().commit();
102:
103: assertNull(em.find(OWLClassG.class, entityG.getUri()));
104: assertNull(em.find(OWLClassH.class, entityH.getUri()));
105: assertNull(em.find(OWLClassA.class, entityA.getUri()));
106: verifyIndividualWasRemoved(entityG.getUri());
107: verifyIndividualWasRemoved(entityH.getUri());
108: verifyIndividualWasRemoved(entityA.getUri());
109: }
110:
111: @Test(expected = IllegalArgumentException.class)
112: public void testRemoveDetached() {
113: this.em = getEntityManager("RemoveDetached", false);
114: assertNull(entityE.getUri());
115: persist(entityE);
116: assertNotNull(entityE.getUri());
117:
118: em.getTransaction().begin();
119: final OWLClassE e = em.find(OWLClassE.class, entityE.getUri());
120: assertNotNull(e);
121: assertTrue(em.contains(e));
122: em.detach(e);
123: assertFalse(em.contains(e));
124: em.remove(e);
125: }
126:
127: @Test
128: public void testRemoveFromSimpleList() {
129: this.em = getEntityManager("RemoveFromSimpleList", false);
130: final int size = 5;
131: entityC.setSimpleList(Generators.createSimpleList(size));
132: em.getTransaction().begin();
133: em.persist(entityC);
134: entityC.getSimpleList().forEach(em::persist);
135: em.getTransaction().commit();
136:
137: final int randIndex = Generators.randomInt(size);
138: final OWLClassA a = em.find(OWLClassA.class, entityC.getSimpleList().get(randIndex).getUri());
139: assertNotNull(a);
140: final OWLClassC c = em.find(OWLClassC.class, entityC.getUri());
141: assertNotNull(c);
142: em.getTransaction().begin();
143: // We have to remove A from the simple list as well because otherwise we would break the chain in instances
144: assertTrue(c.getSimpleList().remove(a));
145: em.remove(a);
146: em.getTransaction().commit();
147:
148: final OWLClassA resA = em.find(OWLClassA.class, a.getUri());
149: assertNull(resA);
150: final OWLClassC resC = em.find(OWLClassC.class, entityC.getUri());
151: boolean found = false;
152: for (OWLClassA aa : resC.getSimpleList()) {
153: if (aa.getUri().equals(a.getUri())) {
154: found = true;
155: break;
156: }
157: }
158: assertFalse(found);
159: }
160:
161: @Test
162: public void testRemoveFromReferencedList() {
163: this.em = getEntityManager("RemoveFromReferencedList", false);
164: final int size = 10;
165: entityC.setReferencedList(Generators.createReferencedList(size));
166: em.getTransaction().begin();
167: em.persist(entityC);
168: entityC.getReferencedList().forEach(em::persist);
169: em.getTransaction().commit();
170:
171: final int randIndex = Generators.randomInt(size);
172: final OWLClassA a = em.find(OWLClassA.class, entityC.getReferencedList().get(randIndex).getUri());
173: assertNotNull(a);
174: final OWLClassC c = em.find(OWLClassC.class, entityC.getUri());
175: assertNotNull(c);
176: em.getTransaction().begin();
177: // We have to remove A from the referenced list as well because otherwise we would break the chain in instances
178: assertTrue(c.getReferencedList().remove(a));
179: em.remove(a);
180: em.getTransaction().commit();
181:
182: final OWLClassA resA = em.find(OWLClassA.class, a.getUri());
183: assertNull(resA);
184: final OWLClassC resC = em.find(OWLClassC.class, entityC.getUri());
185: boolean found = false;
186: for (OWLClassA aa : resC.getReferencedList()) {
187: if (aa.getUri().equals(a.getUri())) {
188: found = true;
189: break;
190: }
191: }
192: assertFalse(found);
193: }
194:
195: @Test
196: public void testRemoveListOwner() {
197: this.em = getEntityManager("RemoveListOwner", false);
198: entityC.setSimpleList(Generators.createSimpleList());
199: entityC.setReferencedList(Generators.createReferencedList());
200: em.getTransaction().begin();
201: em.persist(entityC);
202: entityC.getSimpleList().forEach(em::persist);
203: entityC.getReferencedList().forEach(em::persist);
204: em.getTransaction().commit();
205:
206: final OWLClassC c = em.find(OWLClassC.class, entityC.getUri());
207: assertNotNull(c);
208: em.getTransaction().begin();
209: em.remove(c);
210: em.getTransaction().commit();
211:
212: em.getEntityManagerFactory().getCache().evictAll();
213: for (OWLClassA a : entityC.getSimpleList()) {
214: assertNotNull(em.find(OWLClassA.class, a.getUri()));
215: }
216: for (OWLClassA a : entityC.getReferencedList()) {
217: assertNotNull(em.find(OWLClassA.class, a.getUri()));
218: }
219: }
220:
221: @Test
222: public void testRemoveNotYetCommitted() {
223: this.em = getEntityManager("RemoveNotYetCommitted", false);
224: em.getTransaction().begin();
225: em.persist(entityE);
226: assertTrue(em.contains(entityE));
227: em.remove(entityE);
228: assertFalse(em.contains(entityE));
229: em.getTransaction().commit();
230:
231: final OWLClassE res = em.find(OWLClassE.class, entityE.getUri());
232: assertNull(res);
233: }
234:
235: @Test
236: public void testRemoveMergedWithCascading() {
237: this.em = getEntityManager("CascadeMergeAndRemove", false);
238: em.getTransaction().begin();
239: em.persist(entityG);
240: assertTrue(em.contains(entityA));
241: assertTrue(em.contains(entityG));
242: assertTrue(em.contains(entityH));
243: em.getTransaction().commit();
244: em.clear();
245:
246: final OWLClassG toDetach = em.find(OWLClassG.class, entityG.getUri());
247: assertNotNull(toDetach);
248: em.detach(toDetach);
249: assertFalse(em.contains(toDetach));
250: assertFalse(em.contains(toDetach.getOwlClassH()));
251: assertFalse(em.contains(toDetach.getOwlClassH().getOwlClassA()));
252:
253: em.getTransaction().begin();
254: final OWLClassG toRemove = em.merge(toDetach);
255: em.remove(toRemove);
256: em.getTransaction().commit();
257:
258: assertNull(em.find(OWLClassG.class, entityG.getUri()));
259: assertNull(em.find(OWLClassH.class, entityH.getUri()));
260: assertNull(em.find(OWLClassA.class, entityA.getUri()));
261: }
262:
263: @Test
264: public void removeDeletesAllPropertyAssertionsMappedByEntity() throws Exception {
265: this.em = getEntityManager("RemoveDeletesAllMappedAttributes", false);
266: em.getTransaction().begin();
267: entityC.setSimpleList(Generators.createSimpleList(5));
268: em.persist(entityC);
269: entityC.getSimpleList().forEach(em::persist);
270: em.getTransaction().commit();
271:
272: final OWLClassC toRemove = em.find(OWLClassC.class, entityC.getUri());
273: em.getTransaction().begin();
274: em.remove(toRemove);
275: em.getTransaction().commit();
276:
277: final List<String> properties = resolveCProperties();
278: for (String prop : properties) {
279: assertFalse(
280: em.createNativeQuery("ASK WHERE { ?x ?p ?o .}", Boolean.class).setParameter("x", entityC.getUri())
281: .setParameter("p", URI.create(prop)).getSingleResult());
282: }
283: }
284:
285: private List<String> resolveCProperties() throws Exception {
286: final List<String> lst = new ArrayList<>();
287: for (Field f : OWLClassC.class.getDeclaredFields()) {
288: if (f.getAnnotation(Id.class) != null || EntityPropertiesUtils.isFieldTransient(f)) {
289: continue;
290: }
291: if (f.getAnnotation(OWLDataProperty.class) != null) {
292: lst.add(f.getAnnotation(OWLDataProperty.class).iri());
293: } else if (f.getAnnotation(OWLObjectProperty.class) != null) {
294: lst.add(f.getAnnotation(OWLObjectProperty.class).iri());
295: } else if (f.getAnnotation(OWLAnnotationProperty.class) != null) {
296: lst.add(f.getAnnotation(OWLAnnotationProperty.class).iri());
297: }
298: }
299: return lst;
300: }
301:
302: @Test
303: public void testRemoveUnmappedPropertyValue() {
304: entityB.setProperties(Generators.createProperties());
305: this.em = getEntityManager("RemoveUnmappedPropertyValue", false);
306: em.getTransaction().begin();
307: em.persist(entityB);
308: em.getTransaction().commit();
309:
310: final String property = entityB.getProperties().keySet().iterator().next();
311: final Set<String> values = entityB.getProperties().get(property);
312: assertTrue(values.size() > 0);
313: final String valueToRemove = values.iterator().next();
314: em.getTransaction().begin();
315: final OWLClassB toUpdate = em.find(OWLClassB.class, entityB.getUri());
316: assertNotNull(toUpdate.getProperties());
317: assertTrue(toUpdate.getProperties().containsKey(property));
318: assertTrue(toUpdate.getProperties().get(property).contains(valueToRemove));
319: toUpdate.getProperties().get(property).remove(valueToRemove);
320: em.getTransaction().commit();
321:
322: final OWLClassB result = em.find(OWLClassB.class, entityB.getUri());
323: assertNotNull(result.getProperties());
324: assertTrue(result.getProperties().containsKey(property));
325: assertEquals(values.size() - 1, result.getProperties().get(property).size());
326: assertFalse(result.getProperties().get(property).contains(valueToRemove));
327: }
328:
329: @Test
330: public void testRemoveAllValuesOfUnmappedProperty() {
331: entityB.setProperties(Generators.createProperties());
332: this.em = getEntityManager("RemoveAllValuesOfUnmappedProperty", false);
333: em.getTransaction().begin();
334: em.persist(entityB);
335: em.getTransaction().commit();
336:
337: final String property = entityB.getProperties().keySet().iterator().next();
338: em.getTransaction().begin();
339: final OWLClassB toUpdate = em.find(OWLClassB.class, entityB.getUri());
340: assertNotNull(toUpdate.getProperties());
341: assertTrue(toUpdate.getProperties().containsKey(property));
342: toUpdate.getProperties().remove(property);
343: em.getTransaction().commit();
344:
345: final OWLClassB result = em.find(OWLClassB.class, entityB.getUri());
346: assertNotNull(result.getProperties());
347: assertFalse(result.getProperties().containsKey(property));
348: }
349:
350: @Test
351: public void testRemoveTypedUnmappedPropertyValue() {
352: this.em = getEntityManager("RemoveUnmappedPropertyValueTyped", false);
353: entityP.setProperties(Generators.createTypedProperties(10));
354: persist(entityP);
355:
356: em.getTransaction().begin();
357: final OWLClassP toUpdate = em.find(OWLClassP.class, entityP.getUri());
358: for (Set<Object> set : toUpdate.getProperties().values()) {
359: final Iterator<Object> it = set.iterator();
360: while (it.hasNext()) {
361: it.next();
362: if (Generators.randomBoolean()) {
363: it.remove();
364: }
365: }
366: }
367: em.getTransaction().commit();
368: toUpdate.getProperties().keySet().removeIf(property -> toUpdate.getProperties().get(property).isEmpty());
369: if (toUpdate.getProperties().isEmpty()) {
370: toUpdate.setProperties(null);
371: }
372:
373: final OWLClassP res = em.find(OWLClassP.class, entityP.getUri());
374: assertEquals(toUpdate.getProperties(), res.getProperties());
375: }
376:
377: @Test
378: public void testRemoveAllValuesOfTypedUnmappedProperty() {
379: this.em = getEntityManager("RemoveAllValuesOfUnmappedPropertyTyped", false);
380: entityP.setProperties(Generators.createTypedProperties(15));
381: persist(entityP);
382:
383: final OWLClassP toUpdate = em.find(OWLClassP.class, entityP.getUri());
384: em.detach(toUpdate);
385: // Copy the keys to prevent concurrent modification
386: final Set<URI> keys = new HashSet<>(toUpdate.getProperties().keySet());
387: keys.stream().filter(k -> Generators.randomBoolean())
388: .forEach(key -> toUpdate.getProperties().remove(key));
389: em.getTransaction().begin();
390: final OWLClassP merged = em.merge(toUpdate);
391: assertTrue(TestEnvironmentUtils.arePropertiesEqual(toUpdate.getProperties(), merged.getProperties()));
392: em.getTransaction().commit();
393:
394: final OWLClassP res = em.find(OWLClassP.class, entityP.getUri());
395: assertTrue(TestEnvironmentUtils.arePropertiesEqual(toUpdate.getProperties(), res.getProperties()));
396: }
397:
398: @Test
399: public void testRemoveAllValuesOfPluralPlainIdentifierObjectProperty() {
400: this.em = getEntityManager("RemoveAllValuesOfPluralPlainIdentifierOP", false);
401: entityP.setIndividuals(Generators.createUrls());
402: persist(entityP);
403:
404: final OWLClassP toUpdate = em.find(OWLClassP.class, entityP.getUri());
405: em.getTransaction().begin();
406: toUpdate.getIndividuals().clear();
407: em.getTransaction().commit();
408:
409: final OWLClassP res = em.find(OWLClassP.class, entityP.getUri());
410: assertNull(res.getIndividuals());
411: }
412:
413: @Test
414: public void testSetAnnotationPropertyValueToNull() {
415: this.em = getEntityManager("SetAnnotationPropertyValueToNull", false);
416: entityN.setAnnotationProperty("annotationPropertyValue");
417: persist(entityN);
418:
419: final OWLClassN update = em.find(OWLClassN.class, entityN.getId());
420: assertNotNull(update.getAnnotationProperty());
421: em.getTransaction().begin();
422: update.setAnnotationProperty(null);
423: em.getTransaction().commit();
424:
425: final OWLClassN res = em.find(OWLClassN.class, entityN.getId());
426: assertNull(res.getAnnotationProperty());
427: }
428:
429: @Test
430: public void testSetAnnotationPropertyValueContainingUriToNull() {
431: this.em = getEntityManager("SetAnnotationPropertyValueContainingUriToNull", false);
432: entityN.setAnnotationUri(URI.create("http://krizik.felk.cvut.cz/ontologies/jopa#annotationPropertyValue"));
433: persist(entityN);
434:
435: final OWLClassN update = em.find(OWLClassN.class, entityN.getId());
436: assertNotNull(update.getAnnotationUri());
437: em.getTransaction().begin();
438: update.setAnnotationUri(null);
439: em.getTransaction().commit();
440:
441: final OWLClassN res = em.find(OWLClassN.class, entityN.getId());
442: assertNull(res.getAnnotationUri());
443: }
444:
445: @Test
446: public void testClearUriTypes() {
447: this.em = getEntityManager("ClearUriTypes", false);
448: entityP.setTypes(Generators.createUriTypes());
449: persist(entityP);
450:
451: em.getTransaction().begin();
452: final OWLClassP update = em.find(OWLClassP.class, entityP.getUri());
453: update.getTypes().clear();
454: em.getTransaction().commit();
455:
456: final OWLClassP result = em.find(OWLClassP.class, entityP.getUri());
457: assertNull(result.getTypes());
458: }
459:
460: @Test
461: public void testRemoveDetachedWithCascadedReferenceUsingMergeAndRemove() {
462: this.em = getEntityManager("RemoveDetachedEntityWithCascadedReferenceUsingMergeAndRemove", true);
463: persist(entityH);
464: assertNotNull(em.find(OWLClassH.class, entityH.getUri()));
465: assertNotNull(em.find(OWLClassA.class, entityA.getUri()));
466: final OWLClassH h = new OWLClassH();
467: h.setUri(entityH.getUri());
468: final OWLClassA a = new OWLClassA();
469: a.setUri(entityA.getUri());
470: a.setStringAttribute(entityA.getStringAttribute());
471: a.setTypes(new HashSet<>(entityA.getTypes()));
472: h.setOwlClassA(a);
473:
474: em.clear();
475: em.getTransaction().begin();
476: final OWLClassH toRemove = em.merge(h);
477: em.remove(toRemove);
478: em.getTransaction().commit();
479:
480: assertNull(em.find(OWLClassH.class, entityH.getUri()));
481: assertNull(em.find(OWLClassA.class, entityA.getUri()));
482: }
483:
484: @Test
485: public void removeEntityTwiceInOneTransactionRemovesIt() {
486: this.em = getEntityManager("RemoveDetachedEntityWithCascadedReferenceUsingMergeAndRemove", true);
487: persist(entityA);
488:
489: em.getTransaction().begin();
490: final OWLClassA toRemove = em.merge(entityA);
491: em.remove(toRemove);
492: assertFalse(em.contains(toRemove));
493: em.remove(toRemove);
494: assertFalse(em.contains(toRemove));
495: em.getTransaction().commit();
496:
497: assertNull(em.find(OWLClassA.class, entityA.getUri()));
498: }
499:
500: @Test
501: public void settingDatatypeCollectionToNullRemovesAllValues() {
502: this.em = getEntityManager("settingDatatypeCollectionToNullRemovesAllValues", true);
503: persist(entityM);
504:
505: em.getTransaction().begin();
506: final OWLClassM toClear = em.find(OWLClassM.class, entityM.getKey());
507: toClear.setIntegerSet(null);
508: em.getTransaction().commit();
509:
510: final OWLClassM result = em.find(OWLClassM.class, entityM.getKey());
511: assertNull(result.getIntegerSet());
512: verifyDatatypePropertiesRemoved();
513: }
514:
515: private void verifyDatatypePropertiesRemoved() {
516: for (Integer value : entityM.getIntegerSet()) {
517: assertFalse(em.createNativeQuery("ASK { ?x ?p ?v . }", Boolean.class)
518: .setParameter("x", URI.create(entityM.getKey()))
519: .setParameter("p", URI.create(Vocabulary.p_m_IntegerSet)).setParameter("v", value)
520: .getSingleResult());
521: }
522: }
523:
524: @Test
525: public void clearingDatatypeCollectionRemovesAllValues() {
526: this.em = getEntityManager("clearingDatatypeCollectionRemovesAllValues", true);
527: persist(entityM);
528:
529: em.getTransaction().begin();
530: final OWLClassM toClear = em.find(OWLClassM.class, entityM.getKey());
531: toClear.getIntegerSet().clear();
532: em.getTransaction().commit();
533:
534: final OWLClassM result = em.find(OWLClassM.class, entityM.getKey());
535: // Could be the cached variant, which contains empty collection, or loaded from ontology, which contains null
536: assertTrue(result.getIntegerSet() == null || result.getIntegerSet().isEmpty());
537: verifyDatatypePropertiesRemoved();
538: }
539:
540: @Test
541: public void removingNewlyPersistedInstanceRemovesPendingPersistsAndAllowsTransactionToFinish() {
542: this.em = getEntityManager("removingNewlyPersistedInstanceRemovesPendingPersistsAndAllowsTransactionToFinish",
543: true);
544: em.getTransaction().begin();
545: em.persist(entityD);
546: em.remove(entityD);
547: em.getTransaction().commit();
548:
549: assertNull(em.find(OWLClassD.class, entityD.getUri()));
550: assertNull(em.find(OWLClassA.class, entityA.getUri()));
551: }
552:
553: @Test
554: public void removingNewlyPersistedInstanceRemovesPendingListReferencesAndAllowsTransactionToFinish() {
555: this.em = getEntityManager(
556: "removingNewlyPersistedInstanceRemovesPendingListReferencesAndAllowsTransactionToFinish", true);
557: em.getTransaction().begin();
558: entityC.setSimpleList(Generators.createSimpleList());
559: entityC.setReferencedList(Generators.createReferencedList());
560: em.persist(entityC);
561: em.remove(entityC);
562: em.getTransaction().commit();
563:
564: assertNull(em.find(OWLClassC.class, entityC.getUri()));
565: entityC.getSimpleList().forEach(a -> assertNull(em.find(OWLClassA.class, a.getUri())));
566: entityC.getReferencedList().forEach(a -> assertNull(em.find(OWLClassA.class, a.getUri())));
567: }
568:
569: @Test
570: public void removingListItemsFromNewlyPersistedOwnerRemovesThemFromPendingReferencesAndAllowsTransactionToFinish() {
571: this.em = getEntityManager(
572: "removingListItemsFromNewlyPersistedOwnerRemovesThemFromPendingReferencesAndAllowsTransactionToFinish",
573: false);
574: em.getTransaction().begin();
575: entityC.setSimpleList(Generators.createSimpleList());
576: entityC.setReferencedList(Generators.createReferencedList());
577: em.persist(entityC);
578: entityC.getSimpleList().clear();
579: entityC.getReferencedList().clear();
580: em.getTransaction().commit();
581:
582: final OWLClassC result = em.find(OWLClassC.class, entityC.getUri());
583: assertNotNull(result);
584: assertNull(result.getSimpleList());
585: assertNull(result.getReferencedList());
586: }
587: }