Datei: IntegrationTests/IntegrationTests/Rel1to1Bidirectional.cs

Last Commit (8bd8c9d)

1	//
2	// Copyright (c) 2002-2016 Mirko Matytschak
3	// (www.netdataobjects.de)
4	//
5	// Author: Mirko Matytschak
6	//
7	// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
8	// documentation files (the "Software"), to deal in the Software without restriction, including without limitation
9	// the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
10	// Software, and to permit persons to whom the Software is furnished to do so, subject to the following
11	// conditions:
12
13	// The above copyright notice and this permission notice shall be included in all copies or substantial portions
14	// of the Software.
15	//
16	// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
17	// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18	// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
19	// CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
20	// DEALINGS IN THE SOFTWARE.
21
22
23	using System;
24	using System.Collections;
25	using System.IO;
26	using NUnit.Framework;
27	using Reisekosten.Personal;
28	using Reisekosten;
29	using NDO;
30	using NDO.Linq;
31	using System.Linq;
32	using Microsoft.Extensions.Hosting;
33	using Microsoft.Extensions.Logging;
34	using Microsoft.Extensions.DependencyInjection;
35
36	namespace NdoUnitTests
37	{
38	····/// <summary>
39	····/// All tests for 1:1-Relations. Bidirectional Composition and Aggregation
40	····/// </summary>
41
42
43	····[TestFixture]
44	····public class Rel1to1Bidirectional : NDOTest
45	····{
46	········public Rel1to1Bidirectional()
47	········{
48	········}
49
50	········private static int count = 0;
51	········private Mitarbeiter m;
52	········private Sozialversicherungsnummer svn;
53	········private Email e;
54	········private Zertifikat z0;
55
56	········[SetUp]
57	········public void Setup()
58	········{
59	············count++;
60	············m = CreateMitarbeiter( "Boris", "Becker" );
61	············svn = new Sozialversicherungsnummer();
62	············svn.SVN = 4711;
63	············e = new Email( "hwk@cortex-brainware.de" );
64	············z0 = new Zertifikat();
65	············z0.Key = 42; // :-)
66	········}
67
68	········public void DeleteAll()
69	········{
70	············var pm = PmFactory.NewPersistenceManager();
71	············IList mitarbeiterListe = pm.GetClassExtent( typeof( Mitarbeiter ), true );
72	············pm.Delete( mitarbeiterListe );
73	············pm.Save();
74
75	············// Delete unbound Soz.V. objects
76	············IList sozListe = pm.GetClassExtent( typeof( Sozialversicherungsnummer ) );
77	············pm.Delete( sozListe );
78	············pm.Save();
79
80	············IList eListe = pm.GetClassExtent( typeof( Email ) );
81	············pm.Delete( eListe );
82	············pm.Save();
83
84	············IList zListe = pm.GetClassExtent( typeof( Zertifikat ) );
85	············pm.Delete( zListe );
86	············pm.Save();
87	········}
88
89	········[TearDown]
90	········public void TearDown()
91	········{
92	············var pm = PmFactory.NewPersistenceManager();
93	············DeleteAll();
94	············pm.Close();
95	············pm = null;
96	········}
97
98
99
100	········#region Composition Tests
101
102	········[Test]
103	········public void CompTestCreateObjectsSave()
104	········{
105	············var pm = PmFactory.NewPersistenceManager();
106	············m.SVN = svn;
107	············pm.MakePersistent( m );
108	············pm.Save();
109	············Assert.That( !m.NDOObjectId.Equals( m.SVN.NDOObjectId ), "Ids should be different" );
110	············m = (Mitarbeiter)pm.FindObject( m.NDOObjectId );
111	············svn = (Sozialversicherungsnummer)pm.FindObject( m.SVN.NDOObjectId );
112	············Assert.That(m != null, "1. Mitarbeiter not found" );
113	············Assert.That(svn != null, "1. SVN not found" );
114	············ObjectId moid = m.NDOObjectId;
115	············ObjectId soid = svn.NDOObjectId;
116	············m = null;
117	············svn = null;
118
119	············pm.UnloadCache();
120	············m = (Mitarbeiter)pm.FindObject( moid );
121	············Sozialversicherungsnummer s2 = m.SVN;
122	············svn = (Sozialversicherungsnummer)pm.FindObject( soid );
123	············Assert.That(m != null, "2. Mitarbeiter not found" );
124	············Assert.That(svn != null, "2. SVN not found" );
125	············Assert.That(Object.ReferenceEquals(svn, s2), "SVN should match" );
126	············Assert.That(Object.ReferenceEquals(m, svn.Angestellter), "Mitarbeiter should match" );
127	········}
128
129	········[Test]
130	········public void SimpleObjectSave()
131	········{
132	············var pm = PmFactory.NewPersistenceManager();
133	············pm.MakePersistent( svn );
134	············pm.Save();
135	············pm.UnloadCache();
136	············IList l = pm.GetClassExtent( typeof( Sozialversicherungsnummer ) );
137	············Assert.That( l.Count == 1, "Sozialversicherungsnummer sollte gespeichert sein" );
138	············pm.Delete( l );
139	············pm.Save();
140	············var text = logger.Text;
141	············pm.UnloadCache();
142	············l = pm.GetClassExtent( typeof( Sozialversicherungsnummer ) );
143	············Assert.That( l.Count == 0, "Sozialversicherungsnummer sollte gelöscht sein" );
144	········}
145
146	········[Test]
147	········public void CompChildAddFail()
148	········{
149	············var pm = PmFactory.NewPersistenceManager();
150	············pm.MakePersistent( svn );
151	············var thrown = false;
152	············try
153	············{
154	················svn.Angestellter = m;
155	············}
156	············catch (NDOException)
157	············{
158	················thrown = true;
159	············}
160	············Assert.That(true ==··thrown );
161	········}
162
163	········[Test]
164	········public void CompChildAddFail2()
165	········{
166	············var pm = PmFactory.NewPersistenceManager();
167	············pm.MakePersistent( svn );
168	············pm.Save();
169	············var thrown = false;
170	············try
171	············{
172	················svn.Angestellter = m;
173	············}
174	············catch (NDOException)
175	············{
176	················thrown = true;
177	············}
178	············Assert.That(true ==··thrown );
179	········}
180
181	········[Test]
182	········public void CompChildAdd3()
183	········{
184	············var pm = PmFactory.NewPersistenceManager();
185	············pm.MakePersistent( m );
186	············pm.Save();
187	············m.SVN = svn;
188	············var thrown = false;
189	············try
190	············{
191	················svn.Angestellter = m;
192	············}
193	············catch (NDOException)
194	············{
195	················thrown = true;
196	············}
197	············Assert.That(true ==··thrown );
198	········}
199
200	········[Test]
201	········public void CompChildAdd4()
202	········{
203	············var pm = PmFactory.NewPersistenceManager();
204	············pm.MakePersistent( m );
205	············pm.Save();
206	············m.SVN = svn;
207	············var thrown = false;
208	············try
209	············{
210	················svn.Angestellter = null; // Cannot change relation through child
211	············}
212	············catch (NDOException)
213	············{
214	················thrown = true;
215	············}
216	············Assert.That(true ==··thrown );
217	········}
218
219	········[Test]
220	········public void CompTestAddObjectSave()
221	········{
222	············var pm = PmFactory.NewPersistenceManager();
223	············pm.MakePersistent( m );
224	············pm.Save();
225	············m.SVN = svn;
226	············Assert.That(NDOObjectState.Created ==··svn.NDOObjectState, "1. Wrong state" );
227	············Assert.That(Object.ReferenceEquals(m, svn.Angestellter), "1. Backlink wrong" );
228	············pm.Save();
229	············m = (Mitarbeiter)pm.FindObject( m.NDOObjectId );
230	············svn = (Sozialversicherungsnummer)pm.FindObject( svn.NDOObjectId );
231	············Assert.That(m != null, "1. Mitarbeiter not found" );
232	············Assert.That(svn != null, "1. SVN not found" );
233	············Assert.That(NDOObjectState.Persistent ==··svn.NDOObjectState, "2. Wrong state" );
234	············Assert.That(Object.ReferenceEquals(m, svn.Angestellter), "2. Backlink wrong" );
235	········}
236
237	········[Test]
238	········public void CompTestAddObjectAbort()
239	········{
240	············var pm = PmFactory.NewPersistenceManager();
241	············pm.MakePersistent( m );
242	············pm.Save();
243	············m.SVN = svn;
244	············Assert.That(NDOObjectState.Created ==··svn.NDOObjectState, "1. Wrong state" );
245	············Assert.That(m.SVN != null, "1. SVN not found" );
246	············pm.Abort();
247	············Assert.That(NDOObjectState.Transient ==··svn.NDOObjectState, "2. Wrong state" );
248	············Assert.That(m.SVN == null, "1. SVN should be null" );
249	············Assert.That(svn.Angestellter == null, "1. Mitarbeiter should be null" );
250	········}
251
252
253	········[Test]
254	········public void CompTestReplaceChildSave()
255	········{
256	············var pm = PmFactory.NewPersistenceManager();
257	············pm.MakePersistent( m );
258	············m.SVN = svn;
259	············pm.Save();
260	············Assert.That(m.SVN != null, "1. SVN not found" );
261	············Sozialversicherungsnummer svn2 = new Sozialversicherungsnummer();
262	············svn2.SVN = 0815;
263	············m.SVN = svn2;
264	············Assert.That(NDOObjectState.Deleted ==··svn.NDOObjectState, "1. Wrong state" );
265	············Assert.That(NDOObjectState.Created ==··svn2.NDOObjectState, "2. Wrong state" );
266	············Assert.That(svn.Angestellter == null, "3. No relation to Mitarbeiter" );
267	············Assert.That(Object.ReferenceEquals(svn2.Angestellter, m), "4. Mitarbeiter should be same" );
268	············Assert.That(Object.ReferenceEquals(m.SVN, svn2), "5. SVN should be same" );
269	············pm.Save();
270	············Assert.That(NDOObjectState.Transient ==··svn.NDOObjectState, "6. Wrong state" );
271	············Assert.That(NDOObjectState.Persistent ==··svn2.NDOObjectState, "7. Wrong state" );
272	············Assert.That(svn.Angestellter == null, "8. No relation to Mitarbeiter" );
273	············Assert.That(Object.ReferenceEquals(svn2.Angestellter, m), "9. Mitarbeiter should be same" );
274	············Assert.That(Object.ReferenceEquals(m.SVN, svn2), "10. SVN should be same" );
275	········}
276
277	········[Test]
278	········public void CompTestReplaceChildAbort()
279	········{
280	············var pm = PmFactory.NewPersistenceManager();
281	············pm.MakePersistent( m );
282	············m.SVN = svn;
283	············Assert.That(Object.ReferenceEquals(svn.Angestellter, m), "1. Mitarbeiter should be same" );
284	············pm.Save();
285	············Assert.That(m.SVN != null, "1. SVN not found" );
286	············Sozialversicherungsnummer svn2 = new Sozialversicherungsnummer();
287	············svn2.SVN = 0815;
288	············m.SVN = svn2;
289	············pm.Abort();
290	············Assert.That(NDOObjectState.Transient ==··svn2.NDOObjectState, "1. Wrong state" );
291	············Assert.That(NDOObjectState.Persistent ==··svn.NDOObjectState, "2. Wrong state" );
292	············Assert.That(svn2.Angestellter == null, "3. No relation to Mitarbeiter" );
293	············Assert.That(Object.ReferenceEquals(svn.Angestellter, m), "4. Mitarbeiter should be same" );
294	············Assert.That(Object.ReferenceEquals(m.SVN, svn), "5. SVN should be same" );
295	········}
296
297	········[Test]
298	········public void CompTestReplaceParent()
299	········{
300	············var pm = PmFactory.NewPersistenceManager();
301	············pm.MakePersistent( m );
302	············m.SVN = svn;
303	············pm.Save();
304	············Assert.That(m.SVN != null, "1. SVN not found" );
305	············Mitarbeiter m2 = CreateMitarbeiter( "Andre", "Agassi" );
306	············var thrown = false;
307	············try
308	············{
309	················svn.Angestellter = m2;
310	············}
311	············catch (NDOException)
312	············{
313	················thrown = true;
314	············}
315	············Assert.That(true ==··thrown );
316	········}
317
318
319	········[Test]
320	········public void CompTestRemoveObjectSave()
321	········{
322	············var pm = PmFactory.NewPersistenceManager();
323	············pm.MakePersistent( m );
324	············m.SVN = svn;
325	············pm.Save();
326	············ObjectId moid = m.NDOObjectId;
327	············Assert.That(m.SVN != null, "1. SVN not found" );
328	············m.SVN = null;
329	············Assert.That(NDOObjectState.Deleted ==··svn.NDOObjectState, "1. Wrong state" );
330	············Assert.That(m.SVN == null, "1. SVN should be null" );
331	············Assert.That(svn.Angestellter == null, "1. Mitarbeiter should be null" );
332	············pm.Save();
333	············Assert.That(m.SVN == null, "2. SVN should be null" );
334	············Assert.That(NDOObjectState.Transient ==··svn.NDOObjectState, "2. Wrong state" );
335	············moid = m.NDOObjectId;
336	············pm.UnloadCache();
337	············m = (Mitarbeiter)pm.FindObject( moid );
338	············Assert.That(m != null, "3. Mitarbeiter not found" );
339	············Assert.That(m.SVN == null, "3. SVN should be null" );
340	········}
341
342	········[Test]
343	········public void CompTestRemoveObjectAbort()
344	········{
345	············var pm = PmFactory.NewPersistenceManager();
346	············pm.MakePersistent( m );
347	············m.SVN = svn;
348	············pm.Save();
349	············Assert.That(m.SVN != null, "1. SVN not found" );
350	············m.SVN = null;
351	············Assert.That(NDOObjectState.Deleted ==··svn.NDOObjectState, "1. Wrong state" );
352	············Assert.That(m.SVN == null, "2. SVN should be null" );
353	············pm.Abort();
354	············Assert.That(m.SVN != null, "2. SVN not found" );
355	············Assert.That(NDOObjectState.Persistent ==··svn.NDOObjectState, "2. Wrong state" );
356	············Assert.That(Object.ReferenceEquals(m, svn.Angestellter), "2. Backlink wrong" );
357	········}
358
359	········[Test]
360	········public void CompTestRemoveParentSave()
361	········{
362	············var pm = PmFactory.NewPersistenceManager();
363	············pm.MakePersistent( m );
364	············m.SVN = svn;
365	············pm.Save();
366	············Assert.That(svn.Angestellter != null, "1. Mitarbeiter not found" );
367	············var thrown = false;
368	············try
369	············{
370	················svn.Angestellter = null;··// Cannot manipulate composition through child object.
371	············}
372	············catch (NDOException)
373	············{
374	················thrown = true;
375	············}
376	············Assert.That(true ==··thrown );
377	········}
378
379
380	········[Test]
381	········public void CompTestDeleteSave()
382	········{
383	············var pm = PmFactory.NewPersistenceManager();
384	············pm.MakePersistent( m );
385	············pm.Save();
386	············m.SVN = svn;
387	············pm.Save();
388	············pm.Delete( m );
389	············Assert.That(NDOObjectState.Deleted ==··m.NDOObjectState, "1. Wrong state" );
390	············Assert.That(NDOObjectState.Deleted ==··svn.NDOObjectState, "2. Wrong state" );
391	············pm.Save();
392	············Assert.That(NDOObjectState.Transient ==··m.NDOObjectState, "1. Wrong state" );
393	············Assert.That(NDOObjectState.Transient ==··svn.NDOObjectState, "2. Wrong state" );
394	············// Objects should retain relations in memory
395	············Assert.That(m.SVN != null, "3. SVN shouldn't be null" );
396	············Assert.That(svn.Angestellter == null, "3. Mitarbeiter should be null" );
397	········}
398
399	········[Test]
400	········public void CompTestDeleteChildSave()
401	········{
402	············var pm = PmFactory.NewPersistenceManager();
403	············bool thrown = false;
404	············pm.MakePersistent( m );
405	············pm.Save();
406	············m.SVN = svn;
407	············pm.Save();
408	············try
409	············{
410	················pm.Delete( svn ); // Should throw an Exception
411	············}
412	············catch (NDOException e)
413	············{
414	················thrown = true;
415	············}
416	············Assert.That( thrown, "Exception mösste ausgelöst worden sein" );
417	········}
418
419
420	········[Test]
421	········public void CompTestDeleteAbort()
422	········{
423	············var pm = PmFactory.NewPersistenceManager();
424	············pm.MakePersistent( m );
425	············pm.Save();
426	············m.SVN = svn;
427	············pm.Save();
428	············pm.Delete( m );
429	············Assert.That(NDOObjectState.Deleted ==··m.NDOObjectState, "1. Wrong state" );
430	············Assert.That(NDOObjectState.Deleted ==··svn.NDOObjectState, "2. Wrong state" );
431	············pm.Abort();
432	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "1. Wrong state" );
433	············Assert.That(NDOObjectState.Persistent ==··svn.NDOObjectState, "2. Wrong state" );
434	············Assert.That(m.SVN != null, "2. SVN not found" );
435	············Assert.That(Object.ReferenceEquals(m, svn.Angestellter), "2. Backlink wrong" );
436	········}
437
438	········[Test]
439	········public void CompTestCreateDelete()
440	········{
441	············var pm = PmFactory.NewPersistenceManager();
442	············pm.MakePersistent( m );
443	············m.SVN = svn;
444	············pm.Delete( m );
445	············Assert.That(NDOObjectState.Transient ==··m.NDOObjectState, "1. Wrong state" );
446	············Assert.That(NDOObjectState.Transient ==··svn.NDOObjectState, "2. Wrong state" );
447	············// Objects should retain relations in memory
448	············Assert.That(m.SVN != null, "3. SVN shouldn't be null" );
449	············Assert.That(svn.Angestellter == null, "3. Mitarbeiter should be null" );
450	········}
451
452	········[Test]
453	········public void CompTestAddRemoveSave()
454	········{
455	············var pm = PmFactory.NewPersistenceManager();
456	············pm.MakePersistent( m );
457	············pm.Save();
458	············m.SVN = svn;
459	············m.SVN = null;
460	············Assert.That(NDOObjectState.Transient ==··svn.NDOObjectState, "1. Wrong state" );
461	············Assert.That(m.SVN == null, "1. SVN should be null" );
462	············Assert.That(svn.Angestellter == null, "1. Mitarbeiter should be null" );
463	············pm.Save();
464	············Assert.That(NDOObjectState.Transient ==··svn.NDOObjectState, "2. Wrong state" );
465	············Assert.That(m.SVN == null, "2. SVN should be null" );
466	············Assert.That(svn.Angestellter == null, "3. Mitarbeiter should be null" );
467	········}
468
469	········[Test]
470	········public void CompTestAddRemoveAbort()
471	········{
472	············var pm = PmFactory.NewPersistenceManager();
473	············pm.MakePersistent( m );
474	············pm.Save();
475	············m.SVN = svn;
476	············m.SVN = null;
477	············Assert.That(NDOObjectState.Transient ==··svn.NDOObjectState, "1. Wrong state" );
478	············pm.Abort();
479	············Assert.That(NDOObjectState.Transient ==··svn.NDOObjectState, "2. Wrong state" );
480	············Assert.That(m.SVN == null, "2. SVN should be null" );
481	············Assert.That(svn.Angestellter == null, "3. Mitarbeiter should be null" );
482	········}
483
484
485
486	········[Test]
487	········public void CompTestHollow()
488	········{
489	············var pm = PmFactory.NewPersistenceManager();
490	············m.SVN = svn;
491	············pm.MakePersistent( m );
492	············pm.Save();
493	············pm.MakeHollow( m ); // setzt m.svn auf null
494
495	············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "1: Mitarbeiter should be hollow" );
496	············Assert.That(NDOObjectState.Persistent ==··svn.NDOObjectState, "1: SVN should be persistent" );
497
498	············svn = m.SVN; // ruft LoadData för m auf. m.svm liegt auf dem Cache und ist Persistent
499	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "1: Mitarbeiter should be persistent" );
500	············Assert.That(NDOObjectState.Persistent ==··svn.NDOObjectState, "2: SVN should be persistent" );
501	············ObjectId id = m.NDOObjectId;
502	············pm.Close();
503	············pm = PmFactory.NewPersistenceManager();
504	············m = (Mitarbeiter)pm.FindObject( id );
505	············Assert.That(m != null, "Mitarbeiter not found" );
506	············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "2: Mitarbeiter should be hollow" );
507	············svn = m.SVN;
508	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "2: Mitarbeiter should be persistent" );
509	············Assert.That(svn != null, "SVN not found" );
510	············Assert.That(NDOObjectState.Hollow ==··svn.NDOObjectState, "1: SVN should be hollow" );
511	············Assert.That(Object.ReferenceEquals(m, svn.Angestellter), "2. Backlink wrong" );
512	········}
513
514
515	········[Test]
516	········public void CompTestMakeAllHollow()
517	········{
518	············var pm = PmFactory.NewPersistenceManager();
519	············m.SVN = svn;
520	············pm.MakePersistent( m );
521	············pm.Save();
522	············pm.MakeAllHollow();
523	············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "1: Mitarbeiter should be hollow" );
524	············Assert.That(NDOObjectState.Hollow ==··svn.NDOObjectState, "1: SVN should be hollow" );
525	············Assert.That(Object.ReferenceEquals(m, svn.Angestellter), "2. Backlink wrong" );
526	········}
527
528	········[Test]
529	········public void CompTestMakeAllHollowUnsaved()
530	········{
531	············var pm = PmFactory.NewPersistenceManager();
532	············m.SVN = svn;
533	············pm.MakePersistent( m );
534	············pm.MakeAllHollow();··// before save, objects cannot be made hollow. => in locked objects
535	············Assert.That(NDOObjectState.Created ==··m.NDOObjectState, "1: Mitarbeiter should be created" );
536	············Assert.That(NDOObjectState.Created ==··svn.NDOObjectState, "1: SVN should be created" );
537	········}
538
539	········[Test]
540	········public void CompTestLockRelations()
541	········{
542	············var pm = PmFactory.NewPersistenceManager();
543	············m.SVN = svn;
544	············pm.MakePersistent( m );
545	············m.Adresse = new Adresse();
546	············m.Adresse.Lkz = "Bla";
547	············pm.Save();
548	············pm.Delete( m );
549	············pm.Save();
550	············Assert.That(NDOObjectState.Transient ==··m.NDOObjectState, "1: mitarbeiter should be transient" );
551	············Assert.That(NDOObjectState.Transient ==··m.SVN.NDOObjectState, "1: SVN should be transient" );
552	············Assert.That(NDOObjectState.Transient ==··m.Adresse.NDOObjectState, "1: Adresse should be transient" );
553	········}
554
555	········[Test]
556	········public void CompTestExtentRelatedObjects()
557	········{
558	············var pm = PmFactory.NewPersistenceManager();
559	············m.SVN = svn;
560	············pm.MakePersistent( m );
561	············pm.Save();
562	············IList liste = pm.GetClassExtent( typeof( Mitarbeiter ) );
563	············m = (Mitarbeiter)liste[0];
564	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "1: Mitarbeiter should be persistent" );
565	············Assert.That(m.SVN != null, "2. Relation is missing" );
566	············Assert.That(NDOObjectState.Persistent ==··m.SVN.NDOObjectState, "2.: SVN should be hollow" );
567	············Assert.That(Object.ReferenceEquals(m, svn.Angestellter), "2. Backlink wrong" );
568
569	············pm.UnloadCache();
570	············liste = pm.GetClassExtent( typeof( Mitarbeiter ) );
571	············m = (Mitarbeiter)liste[0];
572	············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "5: Mitarbeiter should be hollow" );
573	············Assert.That(m.SVN != null, "6. Relation is missing" );
574	············Assert.That(NDOObjectState.Hollow ==··m.SVN.NDOObjectState, "8.: SVN should be hollow" );
575	············Assert.That( m != svn.Angestellter, "8a. Should be different objects" );
576	············Assert.That(Object.ReferenceEquals(m, m.SVN.Angestellter), "8b. Mitarbeiter should match" );
577
578	············pm.UnloadCache();
579	············liste = pm.GetClassExtent( typeof( Mitarbeiter ), false );
580	············m = (Mitarbeiter)liste[0];
581	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "9: Mitarbeiter should be persistent" );
582	············Assert.That(m.SVN != null, "10. Relation is missing" );
583	············Assert.That(NDOObjectState.Hollow ==··m.SVN.NDOObjectState, "12.: SVN should be hollow" );
584	············Assert.That( m != svn.Angestellter, "12a. Should be different objects" );
585	············Assert.That(Object.ReferenceEquals(m, m.SVN.Angestellter), "12b. Mitarbeiter should match" );
586	········}
587
588	········#endregion
589
590	········#region Aggregation Tests
591
592	········[Test]
593	········public void AggrTestCreateObjectsTransient()
594	········{
595	············var pm = PmFactory.NewPersistenceManager();
596	············e.Schlüssel = z0;
597	············var thrown = false;
598	············try
599	············{
600	················pm.MakePersistent( e );
601	············}
602	············catch (NDOException)
603	············{
604	················thrown = true;
605	············}
606	············Assert.That(true ==··thrown );
607	········}
608
609	········[Test]
610	········public void AggrTestCreateObjectsTransient2()
611	········{
612	············var pm = PmFactory.NewPersistenceManager();
613	············pm.MakePersistent( e );
614	············var thrown = false;
615	············try
616	············{
617	················e.Schlüssel = z0;
618	············}
619	············catch (NDOException)
620	············{
621	················thrown = true;
622	············}
623	············Assert.That(true ==··thrown );
624	········}
625
626	········[Test]
627	········public void AggrTestCreateObjectsSave()
628	········{
629	············var pm = PmFactory.NewPersistenceManager();
630	············pm.MakePersistent( z0 );
631	············e.Schlüssel = z0;
632	············pm.MakePersistent( e );
633	············pm.Save();
634	············Assert.That( !e.NDOObjectId.Equals( e.Schlüssel.NDOObjectId ), "Ids should be different" );
635	············e = (Email)pm.FindObject( e.NDOObjectId );
636	············z0 = (Zertifikat)pm.FindObject( e.Schlüssel.NDOObjectId );
637	············Assert.That(e != null, "1. Email not found" );
638	············Assert.That(z0 != null, "1. Zertifikat not found" );
639	············ObjectId moid = e.NDOObjectId;
640	············ObjectId soid = z0.NDOObjectId;
641	············e = null;
642	············z0 = null;
643
644	············pm.UnloadCache();
645	············e = (Email)pm.FindObject( moid );
646	············var z1 = pm.Objects<Zertifikat>().Where(z=>z.Oid() == soid.Id.Value).SingleOrDefault();
647	············Assert.That( z1 != null );
648	············Zertifikat z2 = e.Schlüssel;
649	············Assert.That(Object.ReferenceEquals(z1, z2));
650	············z0 = (Zertifikat)pm.FindObject( soid );
651	············Assert.That(e != null, "2. Email not found" );
652	············Assert.That(z0 != null, "2. Zertifikat not found" );
653	············Assert.That(Object.ReferenceEquals(z0, z2), "Zertifikat should match" );
654	············Assert.That(Object.ReferenceEquals(e, z0.Adresse), "Email should match" );
655	········}
656
657	········[Test]
658	········public void AggrTestCreateObjectsWithTransaction()
659	········{
660	············var pm = PmFactory.NewPersistenceManager();
661	············var tm = pm.TransactionMode;
662	············try
663	············{
664	················// See Issue #1145
665	················// The test would fail, if we didn't alter the update rank
666	················// according to the actual situation, that e has a valid database id.
667	················// The test would fail, because the update rank would cause e to be saved first
668	················// at the 2nd Save() call.
669	················pm.TransactionMode = TransactionMode.Optimistic;
670	················pm.MakePersistent( e );
671	················pm.Save( true );
672	················pm.MakePersistent( z0 );
673	················e.Schlüssel = z0;
674	················pm.Save();
675	················pm.UnloadCache();
676	················pm.TransactionMode = TransactionMode.None;
677	················var email = pm.Objects<Email>().Single();
678	················Assert.That(email.Schlüssel··!= null);
679	················Assert.That(42 ==··email.Schlüssel.Key );
680	················pm.UnloadCache();
681	················var zertifikat = pm.Objects<Zertifikat>().Single();
682	················Assert.That(zertifikat.Adresse··!= null);
683	············}
684	············finally
685	············{
686	················pm.TransactionMode = tm;
687	············}
688	········}
689
690
691	········[Test]
692	········public void AggrSimpleObjectSave()
693	········{
694	············var pm = PmFactory.NewPersistenceManager();
695	············pm.MakePersistent( z0 );
696	············pm.Save();
697	········}
698
699	········[Test]
700	········public void AggrChildAddFail()
701	········{
702	············var pm = PmFactory.NewPersistenceManager();
703	············pm.MakePersistent( z0 );
704	············pm.MakePersistent( e );
705	············z0.Adresse = e;
706	········}
707
708	········[Test]
709	········public void AggrChildAddFail2()
710	········{
711	············var pm = PmFactory.NewPersistenceManager();
712	············pm.MakePersistent( e );
713	············pm.MakePersistent( z0 );
714	············pm.Save();
715	············z0.Adresse = e;
716	········}
717
718	········[Test]
719	········public void AggrChildAdd3()
720	········{
721	············var pm = PmFactory.NewPersistenceManager();
722	············pm.MakePersistent( e );
723	············pm.MakePersistent( z0 );
724	············pm.Save();
725	············e.Schlüssel = z0;
726	············z0.Adresse = e;
727	········}
728
729	········[Test]
730	········public void AggrChildAdd4()
731	········{
732	············var pm = PmFactory.NewPersistenceManager();
733	············pm.MakePersistent( z0 );
734	············pm.MakePersistent( e );
735	············pm.Save();
736	············e.Schlüssel = z0;
737	············z0.Adresse = null;
738	········}
739
740	········[Test]
741	········public void AggrTestAddObjectSave()
742	········{
743	············var pm = PmFactory.NewPersistenceManager();
744	············pm.MakePersistent( z0 );
745	············pm.MakePersistent( e );
746	············pm.Save();
747	············e.Schlüssel = z0;
748	············Assert.That(NDOObjectState.PersistentDirty ==··z0.NDOObjectState, "1. Wrong state" );
749	············Assert.That(Object.ReferenceEquals(e, z0.Adresse), "1. Backlink wrong" );
750	············pm.Save();
751	············e = (Email)pm.FindObject( e.NDOObjectId );
752	············z0 = (Zertifikat)pm.FindObject( z0.NDOObjectId );
753	············Assert.That(e != null, "1. Email not found" );
754	············Assert.That(z0 != null, "1. Zertifikat not found" );
755	············Assert.That(NDOObjectState.Persistent ==··z0.NDOObjectState, "2. Wrong state" );
756	············Assert.That(Object.ReferenceEquals(e, z0.Adresse), "2. Backlink wrong" );
757	········}
758
759	········[Test]
760	········public void AggrTestAddObjectAbort()
761	········{
762	············var pm = PmFactory.NewPersistenceManager();
763	············pm.MakePersistent( z0 );
764	············pm.MakePersistent( e );
765	············pm.Save();
766	············e.Schlüssel = z0;
767	············Assert.That(NDOObjectState.PersistentDirty ==··z0.NDOObjectState, "1. Wrong state" );
768	············Assert.That(e.Schlüssel != null, "1. Zertifikat not found" );
769	············pm.Abort();
770	············Assert.That(NDOObjectState.Persistent ==··z0.NDOObjectState, "2. Wrong state" );
771	············Assert.That(e.Schlüssel == null, "1. Zertifikat should be null" );
772	············Assert.That(z0.Adresse == null, "1. Email should be null" );
773	········}
774
775
776	········[Test]
777	········public void AggrTestReplaceChildSave()
778	········{
779	············var pm = PmFactory.NewPersistenceManager();
780	············pm.MakePersistent( z0 );
781	············pm.MakePersistent( e );
782	············e.Schlüssel = z0;
783	············pm.Save();
784	············Assert.That(e.Schlüssel != null, "1. Zertifikat not found" );
785	············Zertifikat z2 = new Zertifikat();
786	············z2.Key = 0815;
787	············pm.MakePersistent( z2 );
788	············e.Schlüssel = z2;
789	············Assert.That(NDOObjectState.PersistentDirty ==··z0.NDOObjectState, "1. Wrong state" );
790	············Assert.That(NDOObjectState.Created ==··z2.NDOObjectState, "2. Wrong state" );
791	············Assert.That(z0.Adresse == null, "3. No relation to Email" );
792	············Assert.That(Object.ReferenceEquals(z2.Adresse, e), "4. Email should be same" );
793	············Assert.That(Object.ReferenceEquals(e.Schlüssel, z2), "5. Zertifikat should be same" );
794	············pm.Save();
795	············Assert.That(NDOObjectState.Persistent ==··z0.NDOObjectState, "6. Wrong state" );
796	············Assert.That(NDOObjectState.Persistent ==··z2.NDOObjectState, "7. Wrong state" );
797	············Assert.That(z0.Adresse == null, "8. No relation to Email" );
798	············Assert.That(Object.ReferenceEquals(z2.Adresse, e), "9. Email should be same" );
799	············Assert.That(Object.ReferenceEquals(e.Schlüssel, z2), "10. Zertifikat should be same" );
800	········}
801
802	········[Test]
803	········public void AggrTestReplaceChildAbort()
804	········{
805	············var pm = PmFactory.NewPersistenceManager();
806	············pm.MakePersistent( z0 );
807	············pm.MakePersistent( e );
808	············e.Schlüssel = z0;
809	············pm.Save();
810	············Assert.That(e.Schlüssel != null, "1. Zertifikat not found" );
811	············Zertifikat z2 = new Zertifikat();
812	············z2.Key = 0815;
813	············pm.MakePersistent( z2 );
814	············e.Schlüssel = z2;
815	············pm.Abort();
816	············Assert.That(NDOObjectState.Transient ==··z2.NDOObjectState, "1. Wrong state" );
817	············Assert.That(NDOObjectState.Persistent ==··z0.NDOObjectState, "2. Wrong state" );
818	············Assert.That(z2.Adresse == null, "3. No relation to Email" );
819	············Assert.That(Object.ReferenceEquals(z0.Adresse, e), "4. Email should be same" );
820	············Assert.That(Object.ReferenceEquals(e.Schlüssel, z0), "5. Zertifikat should be same" );
821	········}
822
823	········[Test]
824	········public void AggrTestReplaceParentSave()
825	········{
826	············var pm = PmFactory.NewPersistenceManager();
827	············pm.MakePersistent( z0 );
828	············pm.MakePersistent( e );
829	············e.Schlüssel = z0;
830	············pm.Save();
831	············Assert.That(e.Schlüssel != null, "1. Zertifikat not found" );
832	············Email m2 = new Email( "db@cortex-brainware.de" );
833	············pm.MakePersistent( m2 );
834	············z0.Adresse = m2;
835	········}
836
837
838	········[Test]
839	········public void AggrTestRemoveObjectSave()
840	········{
841	············var pm = PmFactory.NewPersistenceManager();
842	············pm.MakePersistent( z0 );
843	············pm.MakePersistent( e );
844	············e.Schlüssel = z0;
845	············pm.Save();
846	············Assert.That(e.Schlüssel != null, "1. Zertifikat not found" );
847	············ObjectId aoid = z0.NDOObjectId;
848	············e.Schlüssel = null;
849	············Assert.That(NDOObjectState.PersistentDirty ==··z0.NDOObjectState, "1. Wrong state" );
850	············Assert.That(e.Schlüssel == null, "1. Zertifikat should be null" );
851	············Assert.That(z0.Adresse == null, "1. Email should be null" );
852	············pm.Save();
853	············Assert.That(e.Schlüssel == null, "2. Zertifikat should be null" );
854	············Assert.That(NDOObjectState.Persistent ==··z0.NDOObjectState, "2. Wrong state" );
855	············ObjectId moid = e.NDOObjectId;
856	············Assert.That( aoid.IsValid(), "Still valid Zertifikat" );
857	············pm.UnloadCache();
858	············e = (Email)pm.FindObject( moid );
859	············Assert.That(e != null, "3. Email not found" );
860	············Assert.That(e.Schlüssel == null, "3. Zertifikat should be null" );
861	········}
862
863	········[Test]
864	········public void AggrTestRemoveObjectAbort()
865	········{
866	············var pm = PmFactory.NewPersistenceManager();
867	············pm.MakePersistent( z0 );
868	············pm.MakePersistent( e );
869	············e.Schlüssel = z0;
870	············pm.Save();
871	············Assert.That(e.Schlüssel != null, "1. Zertifikat not found" );
872	············e.Schlüssel = null;
873	············Assert.That(NDOObjectState.PersistentDirty ==··z0.NDOObjectState, "1. Wrong state" );
874	············Assert.That(e.Schlüssel == null, "2. Zertifikat should be null" );
875	············pm.Abort();
876	············Assert.That(e.Schlüssel != null, "2. Zertifikat not found" );
877	············Assert.That(NDOObjectState.Persistent ==··z0.NDOObjectState, "2. Wrong state" );
878	············Assert.That(Object.ReferenceEquals(e, z0.Adresse), "2. Backlink wrong" );
879	········}
880
881	········[Test]
882	········public void AggrTestRemoveParentSave()
883	········{
884	············var pm = PmFactory.NewPersistenceManager();
885	············pm.MakePersistent( z0 );
886	············pm.MakePersistent( e );
887	············e.Schlüssel = z0;
888	············pm.Save();
889	············Assert.That(z0.Adresse != null, "1. Email not found" );
890	············ObjectId aoid = z0.NDOObjectId;
891	············z0.Adresse = null;
892	············Assert.That(NDOObjectState.PersistentDirty ==··z0.NDOObjectState, "1. Wrong state" );
893	············Assert.That(e.Schlüssel == null, "1. Zertifikat should be null" );
894	············Assert.That(z0.Adresse == null, "1. Email should be null" );
895	············pm.Save();
896	············Assert.That(e.Schlüssel == null, "2. Zertifikat should be null" );
897	············Assert.That(NDOObjectState.Persistent ==··z0.NDOObjectState, "2. Wrong state" );
898	············ObjectId moid = e.NDOObjectId;
899	············Assert.That( aoid.IsValid(), "Zertifikat still valid" );
900	············pm.UnloadCache();
901	············e = (Email)pm.FindObject( moid );
902	············Assert.That(e != null, "3. Email not found" );
903	············Assert.That(e.Schlüssel == null, "3. Zertifikat should be null" );
904	········}
905
906	········[Test]
907	········public void AggrTestRemoveParentAbort()
908	········{
909	············var pm = PmFactory.NewPersistenceManager();
910	············pm.MakePersistent( z0 );
911	············pm.MakePersistent( e );
912	············e.Schlüssel = z0;
913	············pm.Save();
914	············Assert.That(e.Schlüssel != null, "1. Zertifikat not found" );
915	············z0.Adresse = null;
916	············Assert.That(NDOObjectState.PersistentDirty ==··z0.NDOObjectState, "1. Wrong state" );
917	············Assert.That(e.Schlüssel == null, "2. Zertifikat should be null" );
918	············pm.Abort();
919	············Assert.That(e.Schlüssel != null, "2. Zertifikat not found" );
920	············Assert.That(NDOObjectState.Persistent ==··z0.NDOObjectState, "2. Wrong state" );
921	············Assert.That(Object.ReferenceEquals(e, z0.Adresse), "2. Backlink wrong" );
922	········}
923
924	#if false
925	········[Test]
926	········[ExpectedException(typeof(NDOException))]
927	········public void AggrTestDelete () {
928	············pm.MakePersistent(z);
929	············pm.MakePersistent(e);
930	············pm.Save();
931	············e.Schlüssel = z;
932	············pm.Save();
933	············pm.Delete(e);··// Cannot delete object within aggregation
934	········}
935
936
937	········[Test]
938	········[ExpectedException(typeof(NDOException))]
939	········public void AggrTestCreateDelete() {
940	············pm.MakePersistent(z);
941	············pm.MakePersistent(e);
942	············e.Schlüssel = z;
943	············pm.Delete(e);··// Cannot delete object within aggregation
944	········}
945	#endif
946
947	········[Test]
948	········public void AggrTestCreateDeleteAllowed()
949	········{
950	············var pm = PmFactory.NewPersistenceManager();
951	············pm.MakePersistent( z0 );
952	············pm.MakePersistent( e );
953	············e.Schlüssel = z0;
954	············e.Schlüssel = null;
955	············pm.Delete( e );
956	············Assert.That(NDOObjectState.Created ==··z0.NDOObjectState, "1. Wrong state" );
957	············Assert.That(NDOObjectState.Transient ==··e.NDOObjectState, "2. Wrong state" );
958	············Assert.That(e.Schlüssel == null, "3. Zertifikat should be null" );
959	············Assert.That(z0.Adresse == null, "4. Email should be null" );
960	········}
961
962
963	········[Test]
964	········public void AggrTestAddRemoveSave()
965	········{
966	············var pm = PmFactory.NewPersistenceManager();
967	············pm.MakePersistent( e );
968	············pm.MakePersistent( z0 );
969	············pm.Save();
970	············e.Schlüssel = z0;
971	············e.Schlüssel = null;
972	············Assert.That(NDOObjectState.PersistentDirty ==··z0.NDOObjectState, "1. Wrong state" );
973	············Assert.That(e.Schlüssel == null, "1. Zertifikat should be null" );
974	············Assert.That(z0.Adresse == null, "1. Email should be null" );
975	············pm.Save();
976	············Assert.That(NDOObjectState.Persistent ==··z0.NDOObjectState, "2. Wrong state" );
977	············Assert.That(e.Schlüssel == null, "2. Zertifikat should be null" );
978	············Assert.That(z0.Adresse == null, "3. Email should be null" );
979	········}
980
981	········[Test]
982	········public void AggrTestAddRemoveAbort()
983	········{
984	············var pm = PmFactory.NewPersistenceManager();
985	············pm.MakePersistent( e );
986	············pm.MakePersistent( z0 );
987	············pm.Save();
988	············e.Schlüssel = z0;
989	············e.Schlüssel = null;
990	············Assert.That(NDOObjectState.PersistentDirty ==··z0.NDOObjectState, "1. Wrong state" );
991	············pm.Abort();
992	············Assert.That(NDOObjectState.Persistent ==··z0.NDOObjectState, "2. Wrong state" );
993	············Assert.That(e.Schlüssel == null, "2. Zertifikat should be null" );
994	············Assert.That(z0.Adresse == null, "3. Email should be null" );
995	········}
996
997
998
999	········[Test]
1000	········public void AggrTestHollow()
1001	········{
1002	············var pm = PmFactory.NewPersistenceManager();
1003	············pm.MakePersistent( z0 );
1004	············e.Schlüssel = z0;
1005	············pm.MakePersistent( e );
1006	············pm.Save();
1007	············pm.MakeHollow( e ); // setzt e.z auf null
1008
1009	············Assert.That(NDOObjectState.Hollow ==··e.NDOObjectState, "1: Email should be hollow" );
1010	············Assert.That(NDOObjectState.Persistent ==··z0.NDOObjectState, "1: Zertifikat should be persistent" );
1011
1012	············z0 = e.Schlüssel; // ruft LoadData för e auf. e.svm liegt auf dem Cache und ist Persistent
1013	············Assert.That(NDOObjectState.Persistent ==··e.NDOObjectState, "1: Email should be persistent" );
1014	············Assert.That(NDOObjectState.Persistent ==··z0.NDOObjectState, "2: Zertifikat should be persistent" );
1015	············ObjectId id = e.NDOObjectId;
1016	············pm.Close();
1017	············pm = PmFactory.NewPersistenceManager();
1018	············e = (Email)pm.FindObject( id );
1019	············Assert.That(e != null, "Email not found" );
1020	············Assert.That(NDOObjectState.Hollow ==··e.NDOObjectState, "2: Email should be hollow" );
1021	············z0 = e.Schlüssel;
1022	············Assert.That(NDOObjectState.Persistent ==··e.NDOObjectState, "2: Email should be persistent" );
1023	············Assert.That(z0 != null, "Zertifikat not found" );
1024	············Assert.That(NDOObjectState.Hollow ==··z0.NDOObjectState, "1: Zertifikat should be hollow" );
1025	············Assert.That(Object.ReferenceEquals(e, z0.Adresse), "2. Backlink wrong" );
1026	········}
1027
1028
1029	········[Test]
1030	········public void AggrTestMakeAllHollowDelete()
1031	········{
1032	············var pm = PmFactory.NewPersistenceManager();
1033	············pm.MakePersistent( z0 );
1034	············e.Schlüssel = z0;
1035	············pm.MakePersistent( e );
1036	············pm.Save();
1037	············pm.MakeAllHollow();
1038	············Assert.That(NDOObjectState.Hollow ==··e.NDOObjectState, "1: Email should be hollow" );
1039	············Assert.That(NDOObjectState.Hollow ==··z0.NDOObjectState, "1: Zertifikat should be hollow" );
1040	············Zertifikat zz = e.Schlüssel;··// Das lödt das Objekt, deshalb geht es hier!
1041	············e.Schlüssel = null;
1042	············Assert.That(NDOObjectState.PersistentDirty ==··e.NDOObjectState, "2: Email should be persistent dirty" );
1043	············Assert.That(NDOObjectState.PersistentDirty ==··z0.NDOObjectState, "2: Zertifikat should be persistent dirty" );
1044	············Assert.That(e.Schlüssel == null, "3. Email should have no Zertifikat" );
1045	············Assert.That(z0.Adresse == null, "3. Zertifikat should have no Email" );
1046	············pm.Delete( e );
1047	········}
1048
1049	········[Test]
1050	········public void AggrTestMakeAllHollow()
1051	········{
1052	············var pm = PmFactory.NewPersistenceManager();
1053	············pm.MakePersistent( z0 );
1054	············e.Schlüssel = z0;
1055	············pm.MakePersistent( e );
1056	············pm.Save();
1057	············pm.MakeAllHollow();
1058	············Assert.That(NDOObjectState.Hollow ==··e.NDOObjectState, "1: Email should be hollow" );
1059	············Assert.That(NDOObjectState.Hollow ==··z0.NDOObjectState, "1: Zertifikat should be hollow" );
1060	············Assert.That(Object.ReferenceEquals(e, z0.Adresse), "2. Backlink wrong" );
1061	········}
1062
1063	········[Test]
1064	········public void AggrTestMakeAllHollowUnsaved()
1065	········{
1066	············var pm = PmFactory.NewPersistenceManager();
1067	············pm.MakePersistent( z0 );
1068	············e.Schlüssel = z0;
1069	············pm.MakePersistent( e );
1070	············pm.MakeAllHollow();··// before save, objects cannot be made hollow. => in locked objects
1071	············Assert.That(NDOObjectState.Created ==··e.NDOObjectState, "1: Email should be created" );
1072	············Assert.That(NDOObjectState.Created ==··z0.NDOObjectState, "1: Zertifikat should be created" );
1073	········}
1074
1075
1076	········[Test]
1077	········public void AggrTestExtentRelatedObjects()
1078	········{
1079	············var pm = PmFactory.NewPersistenceManager();
1080	············pm.MakePersistent( z0 );
1081	············e.Schlüssel = z0;
1082	············pm.MakePersistent( e );
1083	············pm.Save();
1084	············IList liste = pm.GetClassExtent( typeof( Email ) );
1085	············e = (Email)liste[0];
1086	············Assert.That(NDOObjectState.Persistent ==··e.NDOObjectState, "1: Email should be persistent" );
1087	············Assert.That(e.Schlüssel != null, "2. Relation is missing" );
1088	············Assert.That(NDOObjectState.Persistent ==··e.Schlüssel.NDOObjectState, "2.: Zertifikat should be hollow" );
1089	············Assert.That(Object.ReferenceEquals(e, z0.Adresse), "2. Backlink wrong" );
1090
1091	············pm.UnloadCache();
1092	············liste = pm.GetClassExtent( typeof( Email ) );
1093	············e = (Email)liste[0];
1094	············Assert.That(NDOObjectState.Hollow ==··e.NDOObjectState, "5: Email should be hollow" );
1095	············Assert.That(e.Schlüssel != null, "6. Relation is missing" );
1096	············Assert.That(NDOObjectState.Hollow ==··e.Schlüssel.NDOObjectState, "8.: Zertifikat should be hollow" );
1097	············Assert.That( e != z0.Adresse, "8a. Should be different objects" );
1098	············Assert.That(Object.ReferenceEquals(e, e.Schlüssel.Adresse), "8b. Email should match" );
1099
1100	············pm.UnloadCache();
1101	············liste = pm.GetClassExtent( typeof( Email ), false );
1102	············e = (Email)liste[0];
1103	············Assert.That(NDOObjectState.Persistent ==··e.NDOObjectState, "9: Email should be persistent" );
1104	············Assert.That(e.Schlüssel != null, "10. Relation is missing" );
1105	············Assert.That(NDOObjectState.Hollow ==··e.Schlüssel.NDOObjectState, "12.: Zertifikat should be hollow" );
1106	············Assert.That( e != z0.Adresse, "12a. Should be different objects" );
1107	············Assert.That(Object.ReferenceEquals(e, e.Schlüssel.Adresse), "12b. Email should match" );
1108	········}
1109
1110	········[Test]
1111	········public void BiTest()
1112	········{
1113	············var pm = PmFactory.NewPersistenceManager();
1114	············pm.MakePersistent( e );
1115	············pm.MakePersistent( z0 );
1116	············//············System.Diagnostics.Debug.WriteLine("e:" + e.NDOObjectId.ExpressionString);
1117	············//············System.Diagnostics.Debug.WriteLine("z:" + z.NDOObjectId.ExpressionString);
1118	············e.Schlüssel = this.z0;
1119	············pm.Save();
1120	············//············System.Diagnostics.Debug.WriteLine("e:" + e.NDOObjectId.ExpressionString);
1121	············//············System.Diagnostics.Debug.WriteLine("z:" + z.NDOObjectId.ExpressionString);
1122
1123	········}
1124
1125
1126	········#endregion
1127
1128	········private void SetupEmail()
1129	········{
1130	············var pm = PmFactory.NewPersistenceManager();
1131	············pm.MakePersistent( e );
1132	············pm.Save();
1133	········}
1134
1135	········private Mitarbeiter CreateMitarbeiter( string vorname, string nachname )
1136	········{
1137	············Mitarbeiter m = new Mitarbeiter();
1138	············m.Vorname = vorname;
1139	············m.Nachname = nachname;
1140	············return m;
1141	········}
1142	····}
1143	}
1144

New Commit (08b23aa)

1	//
2	// Copyright (c) 2002-2016 Mirko Matytschak
3	// (www.netdataobjects.de)
4	//
5	// Author: Mirko Matytschak
6	//
7	// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
8	// documentation files (the "Software"), to deal in the Software without restriction, including without limitation
9	// the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
10	// Software, and to permit persons to whom the Software is furnished to do so, subject to the following
11	// conditions:
12
13	// The above copyright notice and this permission notice shall be included in all copies or substantial portions
14	// of the Software.
15	//
16	// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
17	// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18	// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
19	// CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
20	// DEALINGS IN THE SOFTWARE.
21
22
23	using System;
24	using System.Collections;
25	using System.IO;
26	using NUnit.Framework;
27	using Reisekosten.Personal;
28	using Reisekosten;
29	using NDO;
30	using NDO.Linq;
31	using System.Linq;
32	using Microsoft.Extensions.Hosting;
33	using Microsoft.Extensions.Logging;
34	using Microsoft.Extensions.DependencyInjection;
35
36	namespace NdoUnitTests
37	{
38	····/// <summary>
39	····/// All tests for 1:1-Relations. Bidirectional Composition and Aggregation
40	····/// </summary>
41
42
43	····[TestFixture]
44	····public class Rel1to1Bidirectional : NDOTest
45	····{
46	········public Rel1to1Bidirectional()
47	········{
48	········}
49
50	········private static int count = 0;
51	········private Mitarbeiter m;
52	········private Sozialversicherungsnummer svn;
53	········private Email e;
54	········private Zertifikat z0;
55
56	········[SetUp]
57	········public void Setup()
58	········{
59	············count++;
60	············m = CreateMitarbeiter( "Boris", "Becker" );
61	············svn = new Sozialversicherungsnummer();
62	············svn.SVN = 4711;
63	············e = new Email( "hwk@cortex-brainware.de" );
64	············z0 = new Zertifikat();
65	············z0.Key = 42; // :-)
66	········}
67
68	········public void DeleteAll()
69	········{
70	············var pm = PmFactory.NewPersistenceManager();
71	············IList mitarbeiterListe = pm.GetClassExtent( typeof( Mitarbeiter ), true );
72	············pm.Delete( mitarbeiterListe );
73	············pm.Save();
74
75	············// Delete unbound Soz.V. objects
76	············IList sozListe = pm.GetClassExtent( typeof( Sozialversicherungsnummer ) );
77	············pm.Delete( sozListe );
78	············pm.Save();
79
80	············IList eListe = pm.GetClassExtent( typeof( Email ) );
81	············pm.Delete( eListe );
82	············pm.Save();
83
84	············IList zListe = pm.GetClassExtent( typeof( Zertifikat ) );
85	············pm.Delete( zListe );
86	············pm.Save();
87	········}
88
89	········[TearDown]
90	········public void TearDown()
91	········{
92	············var pm = PmFactory.NewPersistenceManager();
93	············DeleteAll();
94	············pm.Close();
95	············pm = null;
96	········}
97
98
99
100	········#region Composition Tests
101
102	········[Test]
103	········public void CompTestCreateObjectsSave()
104	········{
105	············var pm = PmFactory.NewPersistenceManager();
106	············m.SVN = svn;
107	············pm.MakePersistent( m );
108	············pm.Save();
109	············Assert.That( !m.NDOObjectId.Equals( m.SVN.NDOObjectId ), "Ids should be different" );
110	············m = (Mitarbeiter)pm.FindObject( m.NDOObjectId );
111	············svn = (Sozialversicherungsnummer)pm.FindObject( m.SVN.NDOObjectId );
112	············Assert.That(m != null, "1. Mitarbeiter not found" );
113	············Assert.That(svn != null, "1. SVN not found" );
114	············ObjectId moid = m.NDOObjectId;
115	············ObjectId soid = svn.NDOObjectId;
116	············m = null;
117	············svn = null;
118
119	············pm.UnloadCache();
120	············m = (Mitarbeiter)pm.FindObject( moid );
121	············Sozialversicherungsnummer s2 = m.SVN;
122	············svn = (Sozialversicherungsnummer)pm.FindObject( soid );
123	············Assert.That(m != null, "2. Mitarbeiter not found" );
124	············Assert.That(svn != null, "2. SVN not found" );
125	············Assert.That(Object.ReferenceEquals(svn, s2), "SVN should match" );
126	············Assert.That(Object.ReferenceEquals(m, svn.Angestellter), "Mitarbeiter should match" );
127	········}
128
129	········[Test]
130	········public void SimpleObjectSave()
131	········{
132	············var pm = PmFactory.NewPersistenceManager();
133	············pm.MakePersistent( svn );
134	············pm.Save();
135	············pm.UnloadCache();
136	············IList l = pm.GetClassExtent( typeof( Sozialversicherungsnummer ) );
137	············Assert.That( l.Count == 1, "Sozialversicherungsnummer sollte gespeichert sein" );
138	············pm.Delete( l );
139	············pm.Save();

140	············pm.UnloadCache();
141	············l = pm.GetClassExtent( typeof( Sozialversicherungsnummer ) );
142	············Assert.That( l.Count == 0, "Sozialversicherungsnummer sollte gelöscht sein" );
143	········}
144
145	········[Test]
146	········public void CompChildAddFail()
147	········{
148	············var pm = PmFactory.NewPersistenceManager();
149	············pm.MakePersistent( svn );
150	············var thrown = false;
151	············try
152	············{
153	················svn.Angestellter = m;
154	············}
155	············catch (NDOException)
156	············{
157	················thrown = true;
158	············}
159	············Assert.That(true ==··thrown );
160	········}
161
162	········[Test]
163	········public void CompChildAddFail2()
164	········{
165	············var pm = PmFactory.NewPersistenceManager();
166	············pm.MakePersistent( svn );
167	············pm.Save();
168	············var thrown = false;
169	············try
170	············{
171	················svn.Angestellter = m;
172	············}
173	············catch (NDOException)
174	············{
175	················thrown = true;
176	············}
177	············Assert.That(true ==··thrown );
178	········}
179
180	········[Test]
181	········public void CompChildAdd3()
182	········{
183	············var pm = PmFactory.NewPersistenceManager();
184	············pm.MakePersistent( m );
185	············pm.Save();
186	············m.SVN = svn;
187	············var thrown = false;
188	············try
189	············{
190	················svn.Angestellter = m;
191	············}
192	············catch (NDOException)
193	············{
194	················thrown = true;
195	············}
196	············Assert.That(true ==··thrown );
197	········}
198
199	········[Test]
200	········public void CompChildAdd4()
201	········{
202	············var pm = PmFactory.NewPersistenceManager();
203	············pm.MakePersistent( m );
204	············pm.Save();
205	············m.SVN = svn;
206	············var thrown = false;
207	············try
208	············{
209	················svn.Angestellter = null; // Cannot change relation through child
210	············}
211	············catch (NDOException)
212	············{
213	················thrown = true;
214	············}
215	············Assert.That(true ==··thrown );
216	········}
217
218	········[Test]
219	········public void CompTestAddObjectSave()
220	········{
221	············var pm = PmFactory.NewPersistenceManager();
222	············pm.MakePersistent( m );
223	············pm.Save();
224	············m.SVN = svn;
225	············Assert.That(NDOObjectState.Created ==··svn.NDOObjectState, "1. Wrong state" );
226	············Assert.That(Object.ReferenceEquals(m, svn.Angestellter), "1. Backlink wrong" );
227	············pm.Save();
228	············m = (Mitarbeiter)pm.FindObject( m.NDOObjectId );
229	············svn = (Sozialversicherungsnummer)pm.FindObject( svn.NDOObjectId );
230	············Assert.That(m != null, "1. Mitarbeiter not found" );
231	············Assert.That(svn != null, "1. SVN not found" );
232	············Assert.That(NDOObjectState.Persistent ==··svn.NDOObjectState, "2. Wrong state" );
233	············Assert.That(Object.ReferenceEquals(m, svn.Angestellter), "2. Backlink wrong" );
234	········}
235
236	········[Test]
237	········public void CompTestAddObjectAbort()
238	········{
239	············var pm = PmFactory.NewPersistenceManager();
240	············pm.MakePersistent( m );
241	············pm.Save();
242	············m.SVN = svn;
243	············Assert.That(NDOObjectState.Created ==··svn.NDOObjectState, "1. Wrong state" );
244	············Assert.That(m.SVN != null, "1. SVN not found" );
245	············pm.Abort();
246	············Assert.That(NDOObjectState.Transient ==··svn.NDOObjectState, "2. Wrong state" );
247	············Assert.That(m.SVN == null, "1. SVN should be null" );
248	············Assert.That(svn.Angestellter == null, "1. Mitarbeiter should be null" );
249	········}
250
251
252	········[Test]
253	········public void CompTestReplaceChildSave()
254	········{
255	············var pm = PmFactory.NewPersistenceManager();
256	············pm.MakePersistent( m );
257	············m.SVN = svn;
258	············pm.Save();
259	············Assert.That(m.SVN != null, "1. SVN not found" );
260	············Sozialversicherungsnummer svn2 = new Sozialversicherungsnummer();
261	············svn2.SVN = 0815;
262	············m.SVN = svn2;
263	············Assert.That(NDOObjectState.Deleted ==··svn.NDOObjectState, "1. Wrong state" );
264	············Assert.That(NDOObjectState.Created ==··svn2.NDOObjectState, "2. Wrong state" );
265	············Assert.That(svn.Angestellter == null, "3. No relation to Mitarbeiter" );
266	············Assert.That(Object.ReferenceEquals(svn2.Angestellter, m), "4. Mitarbeiter should be same" );
267	············Assert.That(Object.ReferenceEquals(m.SVN, svn2), "5. SVN should be same" );
268	············pm.Save();
269	············Assert.That(NDOObjectState.Transient ==··svn.NDOObjectState, "6. Wrong state" );
270	············Assert.That(NDOObjectState.Persistent ==··svn2.NDOObjectState, "7. Wrong state" );
271	············Assert.That(svn.Angestellter == null, "8. No relation to Mitarbeiter" );
272	············Assert.That(Object.ReferenceEquals(svn2.Angestellter, m), "9. Mitarbeiter should be same" );
273	············Assert.That(Object.ReferenceEquals(m.SVN, svn2), "10. SVN should be same" );
274	········}
275
276	········[Test]
277	········public void CompTestReplaceChildAbort()
278	········{
279	············var pm = PmFactory.NewPersistenceManager();
280	············pm.MakePersistent( m );
281	············m.SVN = svn;
282	············Assert.That(Object.ReferenceEquals(svn.Angestellter, m), "1. Mitarbeiter should be same" );
283	············pm.Save();
284	············Assert.That(m.SVN != null, "1. SVN not found" );
285	············Sozialversicherungsnummer svn2 = new Sozialversicherungsnummer();
286	············svn2.SVN = 0815;
287	············m.SVN = svn2;
288	············pm.Abort();
289	············Assert.That(NDOObjectState.Transient ==··svn2.NDOObjectState, "1. Wrong state" );
290	············Assert.That(NDOObjectState.Persistent ==··svn.NDOObjectState, "2. Wrong state" );
291	············Assert.That(svn2.Angestellter == null, "3. No relation to Mitarbeiter" );
292	············Assert.That(Object.ReferenceEquals(svn.Angestellter, m), "4. Mitarbeiter should be same" );
293	············Assert.That(Object.ReferenceEquals(m.SVN, svn), "5. SVN should be same" );
294	········}
295
296	········[Test]
297	········public void CompTestReplaceParent()
298	········{
299	············var pm = PmFactory.NewPersistenceManager();
300	············pm.MakePersistent( m );
301	············m.SVN = svn;
302	············pm.Save();
303	············Assert.That(m.SVN != null, "1. SVN not found" );
304	············Mitarbeiter m2 = CreateMitarbeiter( "Andre", "Agassi" );
305	············var thrown = false;
306	············try
307	············{
308	················svn.Angestellter = m2;
309	············}
310	············catch (NDOException)
311	············{
312	················thrown = true;
313	············}
314	············Assert.That(true ==··thrown );
315	········}
316
317
318	········[Test]
319	········public void CompTestRemoveObjectSave()
320	········{
321	············var pm = PmFactory.NewPersistenceManager();
322	············pm.MakePersistent( m );
323	············m.SVN = svn;
324	············pm.Save();
325	············ObjectId moid = m.NDOObjectId;
326	············Assert.That(m.SVN != null, "1. SVN not found" );
327	············m.SVN = null;
328	············Assert.That(NDOObjectState.Deleted ==··svn.NDOObjectState, "1. Wrong state" );
329	············Assert.That(m.SVN == null, "1. SVN should be null" );
330	············Assert.That(svn.Angestellter == null, "1. Mitarbeiter should be null" );
331	············pm.Save();
332	············Assert.That(m.SVN == null, "2. SVN should be null" );
333	············Assert.That(NDOObjectState.Transient ==··svn.NDOObjectState, "2. Wrong state" );
334	············moid = m.NDOObjectId;
335	············pm.UnloadCache();
336	············m = (Mitarbeiter)pm.FindObject( moid );
337	············Assert.That(m != null, "3. Mitarbeiter not found" );
338	············Assert.That(m.SVN == null, "3. SVN should be null" );
339	········}
340
341	········[Test]
342	········public void CompTestRemoveObjectAbort()
343	········{
344	············var pm = PmFactory.NewPersistenceManager();
345	············pm.MakePersistent( m );
346	············m.SVN = svn;
347	············pm.Save();
348	············Assert.That(m.SVN != null, "1. SVN not found" );
349	············m.SVN = null;
350	············Assert.That(NDOObjectState.Deleted ==··svn.NDOObjectState, "1. Wrong state" );
351	············Assert.That(m.SVN == null, "2. SVN should be null" );
352	············pm.Abort();
353	············Assert.That(m.SVN != null, "2. SVN not found" );
354	············Assert.That(NDOObjectState.Persistent ==··svn.NDOObjectState, "2. Wrong state" );
355	············Assert.That(Object.ReferenceEquals(m, svn.Angestellter), "2. Backlink wrong" );
356	········}
357
358	········[Test]
359	········public void CompTestRemoveParentSave()
360	········{
361	············var pm = PmFactory.NewPersistenceManager();
362	············pm.MakePersistent( m );
363	············m.SVN = svn;
364	············pm.Save();
365	············Assert.That(svn.Angestellter != null, "1. Mitarbeiter not found" );
366	············var thrown = false;
367	············try
368	············{
369	················svn.Angestellter = null;··// Cannot manipulate composition through child object.
370	············}
371	············catch (NDOException)
372	············{
373	················thrown = true;
374	············}
375	············Assert.That(true ==··thrown );
376	········}
377
378
379	········[Test]
380	········public void CompTestDeleteSave()
381	········{
382	············var pm = PmFactory.NewPersistenceManager();
383	············pm.MakePersistent( m );
384	············pm.Save();
385	············m.SVN = svn;
386	············pm.Save();
387	············pm.Delete( m );
388	············Assert.That(NDOObjectState.Deleted ==··m.NDOObjectState, "1. Wrong state" );
389	············Assert.That(NDOObjectState.Deleted ==··svn.NDOObjectState, "2. Wrong state" );
390	············pm.Save();
391	············Assert.That(NDOObjectState.Transient ==··m.NDOObjectState, "1. Wrong state" );
392	············Assert.That(NDOObjectState.Transient ==··svn.NDOObjectState, "2. Wrong state" );
393	············// Objects should retain relations in memory
394	············Assert.That(m.SVN != null, "3. SVN shouldn't be null" );
395	············Assert.That(svn.Angestellter == null, "3. Mitarbeiter should be null" );
396	········}
397
398	········[Test]
399	········public void CompTestDeleteChildSave()
400	········{
401	············var pm = PmFactory.NewPersistenceManager();
402	············bool thrown = false;
403	············pm.MakePersistent( m );
404	············pm.Save();
405	············m.SVN = svn;
406	············pm.Save();
407	············try
408	············{
409	················pm.Delete( svn ); // Should throw an Exception
410	············}
411	············catch (NDOException e)
412	············{
413	················thrown = true;
414	············}
415	············Assert.That( thrown, "Exception mösste ausgelöst worden sein" );
416	········}
417
418
419	········[Test]
420	········public void CompTestDeleteAbort()
421	········{
422	············var pm = PmFactory.NewPersistenceManager();
423	············pm.MakePersistent( m );
424	············pm.Save();
425	············m.SVN = svn;
426	············pm.Save();
427	············pm.Delete( m );
428	············Assert.That(NDOObjectState.Deleted ==··m.NDOObjectState, "1. Wrong state" );
429	············Assert.That(NDOObjectState.Deleted ==··svn.NDOObjectState, "2. Wrong state" );
430	············pm.Abort();
431	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "1. Wrong state" );
432	············Assert.That(NDOObjectState.Persistent ==··svn.NDOObjectState, "2. Wrong state" );
433	············Assert.That(m.SVN != null, "2. SVN not found" );
434	············Assert.That(Object.ReferenceEquals(m, svn.Angestellter), "2. Backlink wrong" );
435	········}
436
437	········[Test]
438	········public void CompTestCreateDelete()
439	········{
440	············var pm = PmFactory.NewPersistenceManager();
441	············pm.MakePersistent( m );
442	············m.SVN = svn;
443	············pm.Delete( m );
444	············Assert.That(NDOObjectState.Transient ==··m.NDOObjectState, "1. Wrong state" );
445	············Assert.That(NDOObjectState.Transient ==··svn.NDOObjectState, "2. Wrong state" );
446	············// Objects should retain relations in memory
447	············Assert.That(m.SVN != null, "3. SVN shouldn't be null" );
448	············Assert.That(svn.Angestellter == null, "3. Mitarbeiter should be null" );
449	········}
450
451	········[Test]
452	········public void CompTestAddRemoveSave()
453	········{
454	············var pm = PmFactory.NewPersistenceManager();
455	············pm.MakePersistent( m );
456	············pm.Save();
457	············m.SVN = svn;
458	············m.SVN = null;
459	············Assert.That(NDOObjectState.Transient ==··svn.NDOObjectState, "1. Wrong state" );
460	············Assert.That(m.SVN == null, "1. SVN should be null" );
461	············Assert.That(svn.Angestellter == null, "1. Mitarbeiter should be null" );
462	············pm.Save();
463	············Assert.That(NDOObjectState.Transient ==··svn.NDOObjectState, "2. Wrong state" );
464	············Assert.That(m.SVN == null, "2. SVN should be null" );
465	············Assert.That(svn.Angestellter == null, "3. Mitarbeiter should be null" );
466	········}
467
468	········[Test]
469	········public void CompTestAddRemoveAbort()
470	········{
471	············var pm = PmFactory.NewPersistenceManager();
472	············pm.MakePersistent( m );
473	············pm.Save();
474	············m.SVN = svn;
475	············m.SVN = null;
476	············Assert.That(NDOObjectState.Transient ==··svn.NDOObjectState, "1. Wrong state" );
477	············pm.Abort();
478	············Assert.That(NDOObjectState.Transient ==··svn.NDOObjectState, "2. Wrong state" );
479	············Assert.That(m.SVN == null, "2. SVN should be null" );
480	············Assert.That(svn.Angestellter == null, "3. Mitarbeiter should be null" );
481	········}
482
483
484
485	········[Test]
486	········public void CompTestHollow()
487	········{
488	············var pm = PmFactory.NewPersistenceManager();
489	············m.SVN = svn;
490	············pm.MakePersistent( m );
491	············pm.Save();
492	············pm.MakeHollow( m ); // setzt m.svn auf null
493
494	············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "1: Mitarbeiter should be hollow" );
495	············Assert.That(NDOObjectState.Persistent ==··svn.NDOObjectState, "1: SVN should be persistent" );
496
497	············svn = m.SVN; // ruft LoadData för m auf. m.svm liegt auf dem Cache und ist Persistent
498	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "1: Mitarbeiter should be persistent" );
499	············Assert.That(NDOObjectState.Persistent ==··svn.NDOObjectState, "2: SVN should be persistent" );
500	············ObjectId id = m.NDOObjectId;
501	············pm.Close();
502	············pm = PmFactory.NewPersistenceManager();
503	············m = (Mitarbeiter)pm.FindObject( id );
504	············Assert.That(m != null, "Mitarbeiter not found" );
505	············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "2: Mitarbeiter should be hollow" );
506	············svn = m.SVN;
507	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "2: Mitarbeiter should be persistent" );
508	············Assert.That(svn != null, "SVN not found" );
509	············Assert.That(NDOObjectState.Hollow ==··svn.NDOObjectState, "1: SVN should be hollow" );
510	············Assert.That(Object.ReferenceEquals(m, svn.Angestellter), "2. Backlink wrong" );
511	········}
512
513
514	········[Test]
515	········public void CompTestMakeAllHollow()
516	········{
517	············var pm = PmFactory.NewPersistenceManager();
518	············m.SVN = svn;
519	············pm.MakePersistent( m );
520	············pm.Save();
521	············pm.MakeAllHollow();
522	············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "1: Mitarbeiter should be hollow" );
523	············Assert.That(NDOObjectState.Hollow ==··svn.NDOObjectState, "1: SVN should be hollow" );
524	············Assert.That(Object.ReferenceEquals(m, svn.Angestellter), "2. Backlink wrong" );
525	········}
526
527	········[Test]
528	········public void CompTestMakeAllHollowUnsaved()
529	········{
530	············var pm = PmFactory.NewPersistenceManager();
531	············m.SVN = svn;
532	············pm.MakePersistent( m );
533	············pm.MakeAllHollow();··// before save, objects cannot be made hollow. => in locked objects
534	············Assert.That(NDOObjectState.Created ==··m.NDOObjectState, "1: Mitarbeiter should be created" );
535	············Assert.That(NDOObjectState.Created ==··svn.NDOObjectState, "1: SVN should be created" );
536	········}
537
538	········[Test]
539	········public void CompTestLockRelations()
540	········{
541	············var pm = PmFactory.NewPersistenceManager();
542	············m.SVN = svn;
543	············pm.MakePersistent( m );
544	············m.Adresse = new Adresse();
545	············m.Adresse.Lkz = "Bla";
546	············pm.Save();
547	············pm.Delete( m );
548	············pm.Save();
549	············Assert.That(NDOObjectState.Transient ==··m.NDOObjectState, "1: mitarbeiter should be transient" );
550	············Assert.That(NDOObjectState.Transient ==··m.SVN.NDOObjectState, "1: SVN should be transient" );
551	············Assert.That(NDOObjectState.Transient ==··m.Adresse.NDOObjectState, "1: Adresse should be transient" );
552	········}
553
554	········[Test]
555	········public void CompTestExtentRelatedObjects()
556	········{
557	············var pm = PmFactory.NewPersistenceManager();
558	············m.SVN = svn;
559	············pm.MakePersistent( m );
560	············pm.Save();
561	············IList liste = pm.GetClassExtent( typeof( Mitarbeiter ) );
562	············m = (Mitarbeiter)liste[0];
563	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "1: Mitarbeiter should be persistent" );
564	············Assert.That(m.SVN != null, "2. Relation is missing" );
565	············Assert.That(NDOObjectState.Persistent ==··m.SVN.NDOObjectState, "2.: SVN should be hollow" );
566	············Assert.That(Object.ReferenceEquals(m, svn.Angestellter), "2. Backlink wrong" );
567
568	············pm.UnloadCache();
569	············liste = pm.GetClassExtent( typeof( Mitarbeiter ) );
570	············m = (Mitarbeiter)liste[0];
571	············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "5: Mitarbeiter should be hollow" );
572	············Assert.That(m.SVN != null, "6. Relation is missing" );
573	············Assert.That(NDOObjectState.Hollow ==··m.SVN.NDOObjectState, "8.: SVN should be hollow" );
574	············Assert.That( m != svn.Angestellter, "8a. Should be different objects" );
575	············Assert.That(Object.ReferenceEquals(m, m.SVN.Angestellter), "8b. Mitarbeiter should match" );
576
577	············pm.UnloadCache();
578	············liste = pm.GetClassExtent( typeof( Mitarbeiter ), false );
579	············m = (Mitarbeiter)liste[0];
580	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "9: Mitarbeiter should be persistent" );
581	············Assert.That(m.SVN != null, "10. Relation is missing" );
582	············Assert.That(NDOObjectState.Hollow ==··m.SVN.NDOObjectState, "12.: SVN should be hollow" );
583	············Assert.That( m != svn.Angestellter, "12a. Should be different objects" );
584	············Assert.That(Object.ReferenceEquals(m, m.SVN.Angestellter), "12b. Mitarbeiter should match" );
585	········}
586
587	········#endregion
588
589	········#region Aggregation Tests
590
591	········[Test]
592	········public void AggrTestCreateObjectsTransient()
593	········{
594	············var pm = PmFactory.NewPersistenceManager();
595	············e.Schlüssel = z0;
596	············var thrown = false;
597	············try
598	············{
599	················pm.MakePersistent( e );
600	············}
601	············catch (NDOException)
602	············{
603	················thrown = true;
604	············}
605	············Assert.That(true ==··thrown );
606	········}
607
608	········[Test]
609	········public void AggrTestCreateObjectsTransient2()
610	········{
611	············var pm = PmFactory.NewPersistenceManager();
612	············pm.MakePersistent( e );
613	············var thrown = false;
614	············try
615	············{
616	················e.Schlüssel = z0;
617	············}
618	············catch (NDOException)
619	············{
620	················thrown = true;
621	············}
622	············Assert.That(true ==··thrown );
623	········}
624
625	········[Test]
626	········public void AggrTestCreateObjectsSave()
627	········{
628	············var pm = PmFactory.NewPersistenceManager();
629	············pm.MakePersistent( z0 );
630	············e.Schlüssel = z0;
631	············pm.MakePersistent( e );
632	············pm.Save();
633	············Assert.That( !e.NDOObjectId.Equals( e.Schlüssel.NDOObjectId ), "Ids should be different" );
634	············e = (Email)pm.FindObject( e.NDOObjectId );
635	············z0 = (Zertifikat)pm.FindObject( e.Schlüssel.NDOObjectId );
636	············Assert.That(e != null, "1. Email not found" );
637	············Assert.That(z0 != null, "1. Zertifikat not found" );
638	············ObjectId moid = e.NDOObjectId;
639	············ObjectId soid = z0.NDOObjectId;
640	············e = null;
641	············z0 = null;
642
643	············pm.UnloadCache();
644	············e = (Email)pm.FindObject( moid );
645	············var z1 = pm.Objects<Zertifikat>().Where(z=>z.Oid() == soid.Id.Value).SingleOrDefault();
646	············Assert.That( z1 != null );
647	············Zertifikat z2 = e.Schlüssel;
648	············Assert.That(Object.ReferenceEquals(z1, z2));
649	············z0 = (Zertifikat)pm.FindObject( soid );
650	············Assert.That(e != null, "2. Email not found" );
651	············Assert.That(z0 != null, "2. Zertifikat not found" );
652	············Assert.That(Object.ReferenceEquals(z0, z2), "Zertifikat should match" );
653	············Assert.That(Object.ReferenceEquals(e, z0.Adresse), "Email should match" );
654	········}
655
656	········[Test]
657	········public void AggrTestCreateObjectsWithTransaction()
658	········{
659	············var pm = PmFactory.NewPersistenceManager();
660	············var tm = pm.TransactionMode;
661	············try
662	············{
663	················// See Issue #1145
664	················// The test would fail, if we didn't alter the update rank
665	················// according to the actual situation, that e has a valid database id.
666	················// The test would fail, because the update rank would cause e to be saved first
667	················// at the 2nd Save() call.
668	················pm.TransactionMode = TransactionMode.Optimistic;
669	················pm.MakePersistent( e );
670	················pm.Save( true );
671	················pm.MakePersistent( z0 );
672	················e.Schlüssel = z0;
673	················pm.Save();
674	················pm.UnloadCache();
675	················pm.TransactionMode = TransactionMode.None;
676	················var email = pm.Objects<Email>().Single();
677	················Assert.That(email.Schlüssel··!= null);
678	················Assert.That(42 ==··email.Schlüssel.Key );
679	················pm.UnloadCache();
680	················var zertifikat = pm.Objects<Zertifikat>().Single();
681	················Assert.That(zertifikat.Adresse··!= null);
682	············}
683	············finally
684	············{
685	················pm.TransactionMode = tm;
686	············}
687	········}
688
689
690	········[Test]
691	········public void AggrSimpleObjectSave()
692	········{
693	············var pm = PmFactory.NewPersistenceManager();
694	············pm.MakePersistent( z0 );
695	············pm.Save();
696	········}
697
698	········[Test]
699	········public void AggrChildAddFail()
700	········{
701	············var pm = PmFactory.NewPersistenceManager();
702	············pm.MakePersistent( z0 );
703	············pm.MakePersistent( e );
704	············z0.Adresse = e;
705	········}
706
707	········[Test]
708	········public void AggrChildAddFail2()
709	········{
710	············var pm = PmFactory.NewPersistenceManager();
711	············pm.MakePersistent( e );
712	············pm.MakePersistent( z0 );
713	············pm.Save();
714	············z0.Adresse = e;
715	········}
716
717	········[Test]
718	········public void AggrChildAdd3()
719	········{
720	············var pm = PmFactory.NewPersistenceManager();
721	············pm.MakePersistent( e );
722	············pm.MakePersistent( z0 );
723	············pm.Save();
724	············e.Schlüssel = z0;
725	············z0.Adresse = e;
726	········}
727
728	········[Test]
729	········public void AggrChildAdd4()
730	········{
731	············var pm = PmFactory.NewPersistenceManager();
732	············pm.MakePersistent( z0 );
733	············pm.MakePersistent( e );
734	············pm.Save();
735	············e.Schlüssel = z0;
736	············z0.Adresse = null;
737	········}
738
739	········[Test]
740	········public void AggrTestAddObjectSave()
741	········{
742	············var pm = PmFactory.NewPersistenceManager();
743	············pm.MakePersistent( z0 );
744	············pm.MakePersistent( e );
745	············pm.Save();
746	············e.Schlüssel = z0;
747	············Assert.That(NDOObjectState.PersistentDirty ==··z0.NDOObjectState, "1. Wrong state" );
748	············Assert.That(Object.ReferenceEquals(e, z0.Adresse), "1. Backlink wrong" );
749	············pm.Save();
750	············e = (Email)pm.FindObject( e.NDOObjectId );
751	············z0 = (Zertifikat)pm.FindObject( z0.NDOObjectId );
752	············Assert.That(e != null, "1. Email not found" );
753	············Assert.That(z0 != null, "1. Zertifikat not found" );
754	············Assert.That(NDOObjectState.Persistent ==··z0.NDOObjectState, "2. Wrong state" );
755	············Assert.That(Object.ReferenceEquals(e, z0.Adresse), "2. Backlink wrong" );
756	········}
757
758	········[Test]
759	········public void AggrTestAddObjectAbort()
760	········{
761	············var pm = PmFactory.NewPersistenceManager();
762	············pm.MakePersistent( z0 );
763	············pm.MakePersistent( e );
764	············pm.Save();
765	············e.Schlüssel = z0;
766	············Assert.That(NDOObjectState.PersistentDirty ==··z0.NDOObjectState, "1. Wrong state" );
767	············Assert.That(e.Schlüssel != null, "1. Zertifikat not found" );
768	············pm.Abort();
769	············Assert.That(NDOObjectState.Persistent ==··z0.NDOObjectState, "2. Wrong state" );
770	············Assert.That(e.Schlüssel == null, "1. Zertifikat should be null" );
771	············Assert.That(z0.Adresse == null, "1. Email should be null" );
772	········}
773
774
775	········[Test]
776	········public void AggrTestReplaceChildSave()
777	········{
778	············var pm = PmFactory.NewPersistenceManager();
779	············pm.MakePersistent( z0 );
780	············pm.MakePersistent( e );
781	············e.Schlüssel = z0;
782	············pm.Save();
783	············Assert.That(e.Schlüssel != null, "1. Zertifikat not found" );
784	············Zertifikat z2 = new Zertifikat();
785	············z2.Key = 0815;
786	············pm.MakePersistent( z2 );
787	············e.Schlüssel = z2;
788	············Assert.That(NDOObjectState.PersistentDirty ==··z0.NDOObjectState, "1. Wrong state" );
789	············Assert.That(NDOObjectState.Created ==··z2.NDOObjectState, "2. Wrong state" );
790	············Assert.That(z0.Adresse == null, "3. No relation to Email" );
791	············Assert.That(Object.ReferenceEquals(z2.Adresse, e), "4. Email should be same" );
792	············Assert.That(Object.ReferenceEquals(e.Schlüssel, z2), "5. Zertifikat should be same" );
793	············pm.Save();
794	············Assert.That(NDOObjectState.Persistent ==··z0.NDOObjectState, "6. Wrong state" );
795	············Assert.That(NDOObjectState.Persistent ==··z2.NDOObjectState, "7. Wrong state" );
796	············Assert.That(z0.Adresse == null, "8. No relation to Email" );
797	············Assert.That(Object.ReferenceEquals(z2.Adresse, e), "9. Email should be same" );
798	············Assert.That(Object.ReferenceEquals(e.Schlüssel, z2), "10. Zertifikat should be same" );
799	········}
800
801	········[Test]
802	········public void AggrTestReplaceChildAbort()
803	········{
804	············var pm = PmFactory.NewPersistenceManager();
805	············pm.MakePersistent( z0 );
806	············pm.MakePersistent( e );
807	············e.Schlüssel = z0;
808	············pm.Save();
809	············Assert.That(e.Schlüssel != null, "1. Zertifikat not found" );
810	············Zertifikat z2 = new Zertifikat();
811	············z2.Key = 0815;
812	············pm.MakePersistent( z2 );
813	············e.Schlüssel = z2;
814	············pm.Abort();
815	············Assert.That(NDOObjectState.Transient ==··z2.NDOObjectState, "1. Wrong state" );
816	············Assert.That(NDOObjectState.Persistent ==··z0.NDOObjectState, "2. Wrong state" );
817	············Assert.That(z2.Adresse == null, "3. No relation to Email" );
818	············Assert.That(Object.ReferenceEquals(z0.Adresse, e), "4. Email should be same" );
819	············Assert.That(Object.ReferenceEquals(e.Schlüssel, z0), "5. Zertifikat should be same" );
820	········}
821
822	········[Test]
823	········public void AggrTestReplaceParentSave()
824	········{
825	············var pm = PmFactory.NewPersistenceManager();
826	············pm.MakePersistent( z0 );
827	············pm.MakePersistent( e );
828	············e.Schlüssel = z0;
829	············pm.Save();
830	············Assert.That(e.Schlüssel != null, "1. Zertifikat not found" );
831	············Email m2 = new Email( "db@cortex-brainware.de" );
832	············pm.MakePersistent( m2 );
833	············z0.Adresse = m2;
834	········}
835
836
837	········[Test]
838	········public void AggrTestRemoveObjectSave()
839	········{
840	············var pm = PmFactory.NewPersistenceManager();
841	············pm.MakePersistent( z0 );
842	············pm.MakePersistent( e );
843	············e.Schlüssel = z0;
844	············pm.Save();
845	············Assert.That(e.Schlüssel != null, "1. Zertifikat not found" );
846	············ObjectId aoid = z0.NDOObjectId;
847	············e.Schlüssel = null;
848	············Assert.That(NDOObjectState.PersistentDirty ==··z0.NDOObjectState, "1. Wrong state" );
849	············Assert.That(e.Schlüssel == null, "1. Zertifikat should be null" );
850	············Assert.That(z0.Adresse == null, "1. Email should be null" );
851	············pm.Save();
852	············Assert.That(e.Schlüssel == null, "2. Zertifikat should be null" );
853	············Assert.That(NDOObjectState.Persistent ==··z0.NDOObjectState, "2. Wrong state" );
854	············ObjectId moid = e.NDOObjectId;
855	············Assert.That( aoid.IsValid(), "Still valid Zertifikat" );
856	············pm.UnloadCache();
857	············e = (Email)pm.FindObject( moid );
858	············Assert.That(e != null, "3. Email not found" );
859	············Assert.That(e.Schlüssel == null, "3. Zertifikat should be null" );
860	········}
861
862	········[Test]
863	········public void AggrTestRemoveObjectAbort()
864	········{
865	············var pm = PmFactory.NewPersistenceManager();
866	············pm.MakePersistent( z0 );
867	············pm.MakePersistent( e );
868	············e.Schlüssel = z0;
869	············pm.Save();
870	············Assert.That(e.Schlüssel != null, "1. Zertifikat not found" );
871	············e.Schlüssel = null;
872	············Assert.That(NDOObjectState.PersistentDirty ==··z0.NDOObjectState, "1. Wrong state" );
873	············Assert.That(e.Schlüssel == null, "2. Zertifikat should be null" );
874	············pm.Abort();
875	············Assert.That(e.Schlüssel != null, "2. Zertifikat not found" );
876	············Assert.That(NDOObjectState.Persistent ==··z0.NDOObjectState, "2. Wrong state" );
877	············Assert.That(Object.ReferenceEquals(e, z0.Adresse), "2. Backlink wrong" );
878	········}
879
880	········[Test]
881	········public void AggrTestRemoveParentSave()
882	········{
883	············var pm = PmFactory.NewPersistenceManager();
884	············pm.MakePersistent( z0 );
885	············pm.MakePersistent( e );
886	············e.Schlüssel = z0;
887	············pm.Save();
888	············Assert.That(z0.Adresse != null, "1. Email not found" );
889	············ObjectId aoid = z0.NDOObjectId;
890	············z0.Adresse = null;
891	············Assert.That(NDOObjectState.PersistentDirty ==··z0.NDOObjectState, "1. Wrong state" );
892	············Assert.That(e.Schlüssel == null, "1. Zertifikat should be null" );
893	············Assert.That(z0.Adresse == null, "1. Email should be null" );
894	············pm.Save();
895	············Assert.That(e.Schlüssel == null, "2. Zertifikat should be null" );
896	············Assert.That(NDOObjectState.Persistent ==··z0.NDOObjectState, "2. Wrong state" );
897	············ObjectId moid = e.NDOObjectId;
898	············Assert.That( aoid.IsValid(), "Zertifikat still valid" );
899	············pm.UnloadCache();
900	············e = (Email)pm.FindObject( moid );
901	············Assert.That(e != null, "3. Email not found" );
902	············Assert.That(e.Schlüssel == null, "3. Zertifikat should be null" );
903	········}
904
905	········[Test]
906	········public void AggrTestRemoveParentAbort()
907	········{
908	············var pm = PmFactory.NewPersistenceManager();
909	············pm.MakePersistent( z0 );
910	············pm.MakePersistent( e );
911	············e.Schlüssel = z0;
912	············pm.Save();
913	············Assert.That(e.Schlüssel != null, "1. Zertifikat not found" );
914	············z0.Adresse = null;
915	············Assert.That(NDOObjectState.PersistentDirty ==··z0.NDOObjectState, "1. Wrong state" );
916	············Assert.That(e.Schlüssel == null, "2. Zertifikat should be null" );
917	············pm.Abort();
918	············Assert.That(e.Schlüssel != null, "2. Zertifikat not found" );
919	············Assert.That(NDOObjectState.Persistent ==··z0.NDOObjectState, "2. Wrong state" );
920	············Assert.That(Object.ReferenceEquals(e, z0.Adresse), "2. Backlink wrong" );
921	········}
922
923	#if false
924	········[Test]
925	········[ExpectedException(typeof(NDOException))]
926	········public void AggrTestDelete () {
927	············pm.MakePersistent(z);
928	············pm.MakePersistent(e);
929	············pm.Save();
930	············e.Schlüssel = z;
931	············pm.Save();
932	············pm.Delete(e);··// Cannot delete object within aggregation
933	········}
934
935
936	········[Test]
937	········[ExpectedException(typeof(NDOException))]
938	········public void AggrTestCreateDelete() {
939	············pm.MakePersistent(z);
940	············pm.MakePersistent(e);
941	············e.Schlüssel = z;
942	············pm.Delete(e);··// Cannot delete object within aggregation
943	········}
944	#endif
945
946	········[Test]
947	········public void AggrTestCreateDeleteAllowed()
948	········{
949	············var pm = PmFactory.NewPersistenceManager();
950	············pm.MakePersistent( z0 );
951	············pm.MakePersistent( e );
952	············e.Schlüssel = z0;
953	············e.Schlüssel = null;
954	············pm.Delete( e );
955	············Assert.That(NDOObjectState.Created ==··z0.NDOObjectState, "1. Wrong state" );
956	············Assert.That(NDOObjectState.Transient ==··e.NDOObjectState, "2. Wrong state" );
957	············Assert.That(e.Schlüssel == null, "3. Zertifikat should be null" );
958	············Assert.That(z0.Adresse == null, "4. Email should be null" );
959	········}
960
961
962	········[Test]
963	········public void AggrTestAddRemoveSave()
964	········{
965	············var pm = PmFactory.NewPersistenceManager();
966	············pm.MakePersistent( e );
967	············pm.MakePersistent( z0 );
968	············pm.Save();
969	············e.Schlüssel = z0;
970	············e.Schlüssel = null;
971	············Assert.That(NDOObjectState.PersistentDirty ==··z0.NDOObjectState, "1. Wrong state" );
972	············Assert.That(e.Schlüssel == null, "1. Zertifikat should be null" );
973	············Assert.That(z0.Adresse == null, "1. Email should be null" );
974	············pm.Save();
975	············Assert.That(NDOObjectState.Persistent ==··z0.NDOObjectState, "2. Wrong state" );
976	············Assert.That(e.Schlüssel == null, "2. Zertifikat should be null" );
977	············Assert.That(z0.Adresse == null, "3. Email should be null" );
978	········}
979
980	········[Test]
981	········public void AggrTestAddRemoveAbort()
982	········{
983	············var pm = PmFactory.NewPersistenceManager();
984	············pm.MakePersistent( e );
985	············pm.MakePersistent( z0 );
986	············pm.Save();
987	············e.Schlüssel = z0;
988	············e.Schlüssel = null;
989	············Assert.That(NDOObjectState.PersistentDirty ==··z0.NDOObjectState, "1. Wrong state" );
990	············pm.Abort();
991	············Assert.That(NDOObjectState.Persistent ==··z0.NDOObjectState, "2. Wrong state" );
992	············Assert.That(e.Schlüssel == null, "2. Zertifikat should be null" );
993	············Assert.That(z0.Adresse == null, "3. Email should be null" );
994	········}
995
996
997
998	········[Test]
999	········public void AggrTestHollow()
1000	········{
1001	············var pm = PmFactory.NewPersistenceManager();
1002	············pm.MakePersistent( z0 );
1003	············e.Schlüssel = z0;
1004	············pm.MakePersistent( e );
1005	············pm.Save();
1006	············pm.MakeHollow( e ); // setzt e.z auf null
1007
1008	············Assert.That(NDOObjectState.Hollow ==··e.NDOObjectState, "1: Email should be hollow" );
1009	············Assert.That(NDOObjectState.Persistent ==··z0.NDOObjectState, "1: Zertifikat should be persistent" );
1010
1011	············z0 = e.Schlüssel; // ruft LoadData för e auf. e.svm liegt auf dem Cache und ist Persistent
1012	············Assert.That(NDOObjectState.Persistent ==··e.NDOObjectState, "1: Email should be persistent" );
1013	············Assert.That(NDOObjectState.Persistent ==··z0.NDOObjectState, "2: Zertifikat should be persistent" );
1014	············ObjectId id = e.NDOObjectId;
1015	············pm.Close();
1016	············pm = PmFactory.NewPersistenceManager();
1017	············e = (Email)pm.FindObject( id );
1018	············Assert.That(e != null, "Email not found" );
1019	············Assert.That(NDOObjectState.Hollow ==··e.NDOObjectState, "2: Email should be hollow" );
1020	············z0 = e.Schlüssel;
1021	············Assert.That(NDOObjectState.Persistent ==··e.NDOObjectState, "2: Email should be persistent" );
1022	············Assert.That(z0 != null, "Zertifikat not found" );
1023	············Assert.That(NDOObjectState.Hollow ==··z0.NDOObjectState, "1: Zertifikat should be hollow" );
1024	············Assert.That(Object.ReferenceEquals(e, z0.Adresse), "2. Backlink wrong" );
1025	········}
1026
1027
1028	········[Test]
1029	········public void AggrTestMakeAllHollowDelete()
1030	········{
1031	············var pm = PmFactory.NewPersistenceManager();
1032	············pm.MakePersistent( z0 );
1033	············e.Schlüssel = z0;
1034	············pm.MakePersistent( e );
1035	············pm.Save();
1036	············pm.MakeAllHollow();
1037	············Assert.That(NDOObjectState.Hollow ==··e.NDOObjectState, "1: Email should be hollow" );
1038	············Assert.That(NDOObjectState.Hollow ==··z0.NDOObjectState, "1: Zertifikat should be hollow" );
1039	············Zertifikat zz = e.Schlüssel;··// Das lödt das Objekt, deshalb geht es hier!
1040	············e.Schlüssel = null;
1041	············Assert.That(NDOObjectState.PersistentDirty ==··e.NDOObjectState, "2: Email should be persistent dirty" );
1042	············Assert.That(NDOObjectState.PersistentDirty ==··z0.NDOObjectState, "2: Zertifikat should be persistent dirty" );
1043	············Assert.That(e.Schlüssel == null, "3. Email should have no Zertifikat" );
1044	············Assert.That(z0.Adresse == null, "3. Zertifikat should have no Email" );
1045	············pm.Delete( e );
1046	········}
1047
1048	········[Test]
1049	········public void AggrTestMakeAllHollow()
1050	········{
1051	············var pm = PmFactory.NewPersistenceManager();
1052	············pm.MakePersistent( z0 );
1053	············e.Schlüssel = z0;
1054	············pm.MakePersistent( e );
1055	············pm.Save();
1056	············pm.MakeAllHollow();
1057	············Assert.That(NDOObjectState.Hollow ==··e.NDOObjectState, "1: Email should be hollow" );
1058	············Assert.That(NDOObjectState.Hollow ==··z0.NDOObjectState, "1: Zertifikat should be hollow" );
1059	············Assert.That(Object.ReferenceEquals(e, z0.Adresse), "2. Backlink wrong" );
1060	········}
1061
1062	········[Test]
1063	········public void AggrTestMakeAllHollowUnsaved()
1064	········{
1065	············var pm = PmFactory.NewPersistenceManager();
1066	············pm.MakePersistent( z0 );
1067	············e.Schlüssel = z0;
1068	············pm.MakePersistent( e );
1069	············pm.MakeAllHollow();··// before save, objects cannot be made hollow. => in locked objects
1070	············Assert.That(NDOObjectState.Created ==··e.NDOObjectState, "1: Email should be created" );
1071	············Assert.That(NDOObjectState.Created ==··z0.NDOObjectState, "1: Zertifikat should be created" );
1072	········}
1073
1074
1075	········[Test]
1076	········public void AggrTestExtentRelatedObjects()
1077	········{
1078	············var pm = PmFactory.NewPersistenceManager();
1079	············pm.MakePersistent( z0 );
1080	············e.Schlüssel = z0;
1081	············pm.MakePersistent( e );
1082	············pm.Save();
1083	············IList liste = pm.GetClassExtent( typeof( Email ) );
1084	············e = (Email)liste[0];
1085	············Assert.That(NDOObjectState.Persistent ==··e.NDOObjectState, "1: Email should be persistent" );
1086	············Assert.That(e.Schlüssel != null, "2. Relation is missing" );
1087	············Assert.That(NDOObjectState.Persistent ==··e.Schlüssel.NDOObjectState, "2.: Zertifikat should be hollow" );
1088	············Assert.That(Object.ReferenceEquals(e, z0.Adresse), "2. Backlink wrong" );
1089
1090	············pm.UnloadCache();
1091	············liste = pm.GetClassExtent( typeof( Email ) );
1092	············e = (Email)liste[0];
1093	············Assert.That(NDOObjectState.Hollow ==··e.NDOObjectState, "5: Email should be hollow" );
1094	············Assert.That(e.Schlüssel != null, "6. Relation is missing" );
1095	············Assert.That(NDOObjectState.Hollow ==··e.Schlüssel.NDOObjectState, "8.: Zertifikat should be hollow" );
1096	············Assert.That( e != z0.Adresse, "8a. Should be different objects" );
1097	············Assert.That(Object.ReferenceEquals(e, e.Schlüssel.Adresse), "8b. Email should match" );
1098
1099	············pm.UnloadCache();
1100	············liste = pm.GetClassExtent( typeof( Email ), false );
1101	············e = (Email)liste[0];
1102	············Assert.That(NDOObjectState.Persistent ==··e.NDOObjectState, "9: Email should be persistent" );
1103	············Assert.That(e.Schlüssel != null, "10. Relation is missing" );
1104	············Assert.That(NDOObjectState.Hollow ==··e.Schlüssel.NDOObjectState, "12.: Zertifikat should be hollow" );
1105	············Assert.That( e != z0.Adresse, "12a. Should be different objects" );
1106	············Assert.That(Object.ReferenceEquals(e, e.Schlüssel.Adresse), "12b. Email should match" );
1107	········}
1108
1109	········[Test]
1110	········public void BiTest()
1111	········{
1112	············var pm = PmFactory.NewPersistenceManager();
1113	············pm.MakePersistent( e );
1114	············pm.MakePersistent( z0 );
1115	············//············System.Diagnostics.Debug.WriteLine("e:" + e.NDOObjectId.ExpressionString);
1116	············//············System.Diagnostics.Debug.WriteLine("z:" + z.NDOObjectId.ExpressionString);
1117	············e.Schlüssel = this.z0;
1118	············pm.Save();
1119	············//············System.Diagnostics.Debug.WriteLine("e:" + e.NDOObjectId.ExpressionString);
1120	············//············System.Diagnostics.Debug.WriteLine("z:" + z.NDOObjectId.ExpressionString);
1121
1122	········}
1123
1124
1125	········#endregion
1126
1127	········private void SetupEmail()
1128	········{
1129	············var pm = PmFactory.NewPersistenceManager();
1130	············pm.MakePersistent( e );
1131	············pm.Save();
1132	········}
1133
1134	········private Mitarbeiter CreateMitarbeiter( string vorname, string nachname )
1135	········{
1136	············Mitarbeiter m = new Mitarbeiter();
1137	············m.Vorname = vorname;
1138	············m.Nachname = nachname;
1139	············return m;
1140	········}
1141	····}
1142	}
1143

Cookie Info