Datei: IntegrationTests/IntegrationTests/Rel1to1Bidirectional.cs

Last Commit (a04c7be)

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

New 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

Cookie Info