Datei: IntegrationTests/IntegrationTests/Rel1to1Bidirectional.cs

Last Commit (08b23aa)

1	//
2	// Copyright (c) 2002-2016 Mirko Matytschak
3	// (www.netdataobjects.de)
4	//
5	// Author: Mirko Matytschak
6	//
7	// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
8	// documentation files (the "Software"), to deal in the Software without restriction, including without limitation
9	// the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
10	// Software, and to permit persons to whom the Software is furnished to do so, subject to the following
11	// conditions:
12
13	// The above copyright notice and this permission notice shall be included in all copies or substantial portions
14	// of the Software.
15	//
16	// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
17	// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18	// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
19	// CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
20	// DEALINGS IN THE SOFTWARE.
21
22
23	using System;
24	using System.Collections;
25	using System.IO;
26	using NUnit.Framework;
27	using Reisekosten.Personal;
28	using Reisekosten;
29	using NDO;
30	using NDO.Linq;
31	using System.Linq;
32	using Microsoft.Extensions.Hosting;
33	using Microsoft.Extensions.Logging;
34	using Microsoft.Extensions.DependencyInjection;
35
36	namespace NdoUnitTests
37	{
38	····/// <summary>
39	····/// All tests for 1:1-Relations. Bidirectional Composition and Aggregation
40	····/// </summary>
41
42
43	····[TestFixture]
44	····public class Rel1to1Bidirectional : NDOTest
45	····{
46	········public Rel1to1Bidirectional()
47	········{
48	········}
49
50	········private static int count = 0;
51	········private Mitarbeiter m;
52	········private Sozialversicherungsnummer svn;
53	········private Email e;
54	········private Zertifikat z0;
55
56	········[SetUp]
57	········public void Setup()
58	········{
59	············count++;
60	············m = CreateMitarbeiter( "Boris", "Becker" );
61	············svn = new Sozialversicherungsnummer();
62	············svn.SVN = 4711;
63	············e = new Email( "hwk@cortex-brainware.de" );
64	············z0 = new Zertifikat();
65	············z0.Key = 42; // :-)
66	········}
67
68	········public void DeleteAll()
69	········{
70	············var pm = PmFactory.NewPersistenceManager();
71	············IList mitarbeiterListe = pm.GetClassExtent( typeof( Mitarbeiter ), true );
72	············pm.Delete( mitarbeiterListe );
73	············pm.Save();
74
75	············// Delete unbound Soz.V. objects
76	············IList sozListe = pm.GetClassExtent( typeof( Sozialversicherungsnummer ) );
77	············pm.Delete( sozListe );
78	············pm.Save();
79
80	············IList eListe = pm.GetClassExtent( typeof( Email ) );
81	············pm.Delete( eListe );
82	············pm.Save();
83
84	············IList zListe = pm.GetClassExtent( typeof( Zertifikat ) );
85	············pm.Delete( zListe );
86	············pm.Save();

87	········}
88
89	········[TearDown]
90	········public void TearDown()
91	········{
92	············var pm = PmFactory.NewPersistenceManager();
93	············DeleteAll();
94	············pm.Close();
95	············pm = null;
96	········}
97
98
99
100	········#region Composition Tests
101
102	········[Test]
103	········public void CompTestCreateObjectsSave()
104	········{
105	var pm = PmFactory. NewPersistenceManager( ) ;

106	············m.SVN = svn;
107	············pm.MakePersistent( m );
108	············pm.Save();
109	············Assert.That( !m.NDOObjectId.Equals( m.SVN.NDOObjectId ), "Ids should be different" );
110	m = ( Mitarbeiter) pm. FindObject( m. NDOObjectId ) ;
111	svn = ( Sozialversicherungsnummer) pm. FindObject( m. SVN. NDOObjectId ) ;
112	Assert. That( m != null, "1. Mitarbeiter not found" ) ;
113	Assert. That( svn != null, "1. SVN not found" ) ;
114	············ObjectId moid = m.NDOObjectId;
115	············ObjectId soid = svn.NDOObjectId;
116	············m = null;
117	············svn = null;
118
119	············pm.UnloadCache();
120	m = ( Mitarbeiter) pm. FindObject( moid ) ;
121	············Sozialversicherungsnummer s2 = m.SVN;
122	svn = ( Sozialversicherungsnummer) pm. FindObject( soid ) ;
123	Assert. That( m != null, "2. Mitarbeiter not found" ) ;
124	Assert. That( svn != null, "2. SVN not found" ) ;
125	Assert. That( Object. ReferenceEquals( svn, s2) , "SVN should match" ) ;
126	Assert. That( Object. ReferenceEquals( m, svn. Angestellter) , "Mitarbeiter should match" ) ;

127	········}
128
129	········[Test]
130	········public void SimpleObjectSave()
131	········{
132	var pm = PmFactory. NewPersistenceManager( ) ;

133	············pm.MakePersistent( svn );
134	············pm.Save();
135	············pm.UnloadCache();
136	············IList l = pm.GetClassExtent( typeof( Sozialversicherungsnummer ) );
137	············Assert.That( l.Count == 1, "Sozialversicherungsnummer sollte gespeichert sein" );
138	············pm.Delete( l );
139	············pm.Save();
140	············pm.UnloadCache();
141	············l = pm.GetClassExtent( typeof( Sozialversicherungsnummer ) );
142	············Assert.That( l.Count == 0, "Sozialversicherungsnummer sollte gelöscht sein" );
143	········}

144
145	········[Test]
146	········public void CompChildAddFail()
147	········{
148	var pm = PmFactory. NewPersistenceManager( ) ;

149	············pm.MakePersistent( svn );
150	············var thrown = false;
151	············try
152	············{
153	················svn.Angestellter = m;
154	············}
155	············catch (NDOException)
156	············{
157	················thrown = true;
158	············}
159	Assert. That( true == thrown ) ;
160	········}

161
162	········[Test]
163	········public void CompChildAddFail2()
164	········{
165	var pm = PmFactory. NewPersistenceManager( ) ;

166	············pm.MakePersistent( svn );
167	············pm.Save();
168	············var thrown = false;
169	············try
170	············{
171	················svn.Angestellter = m;
172	············}
173	············catch (NDOException)
174	············{
175	················thrown = true;
176	············}
177	Assert. That( true == thrown ) ;
178	········}

179
180	········[Test]
181	········public void CompChildAdd3()
182	········{
183	var pm = PmFactory. NewPersistenceManager( ) ;

184	············pm.MakePersistent( m );
185	············pm.Save();
186	············m.SVN = svn;
187	············var thrown = false;
188	············try
189	············{
190	················svn.Angestellter = m;
191	············}
192	············catch (NDOException)
193	············{
194	················thrown = true;
195	············}
196	Assert. That( true == thrown ) ;
197	········}

198
199	········[Test]
200	········public void CompChildAdd4()
201	········{
202	var pm = PmFactory. NewPersistenceManager( ) ;

203	············pm.MakePersistent( m );
204	············pm.Save();
205	············m.SVN = svn;
206	············var thrown = false;
207	············try
208	············{
209	················svn.Angestellter = null; // Cannot change relation through child
210	············}
211	············catch (NDOException)
212	············{
213	················thrown = true;
214	············}
215	Assert. That( true == thrown ) ;
216	········}

217
218	········[Test]
219	········public void CompTestAddObjectSave()
220	········{
221	var pm = PmFactory. NewPersistenceManager( ) ;

222	············pm.MakePersistent( m );
223	············pm.Save();
224	············m.SVN = svn;
225	Assert. That( NDOObjectState. Created == svn. NDOObjectState, "1. Wrong state" ) ;
226	Assert. That( Object. ReferenceEquals( m, svn. Angestellter) , "1. Backlink wrong" ) ;
227	············pm.Save();
228	m = ( Mitarbeiter) pm. FindObject( m. NDOObjectId ) ;
229	svn = ( Sozialversicherungsnummer) pm. FindObject( svn. NDOObjectId ) ;
230	Assert. That( m != null, "1. Mitarbeiter not found" ) ;
231	Assert. That( svn != null, "1. SVN not found" ) ;
232	Assert. That( NDOObjectState. Persistent == svn. NDOObjectState, "2. Wrong state" ) ;
233	Assert. That( Object. ReferenceEquals( m, svn. Angestellter) , "2. Backlink wrong" ) ;

234	········}
235
236	········[Test]
237	········public void CompTestAddObjectAbort()
238	········{
239	var pm = PmFactory. NewPersistenceManager( ) ;

240	············pm.MakePersistent( m );
241	············pm.Save();
242	············m.SVN = svn;
243	Assert. That( NDOObjectState. Created == svn. NDOObjectState, "1. Wrong state" ) ;
244	Assert. That( m. SVN != null, "1. SVN not found" ) ;
245	············pm.Abort();
246	Assert. That( NDOObjectState. Transient == svn. NDOObjectState, "2. Wrong state" ) ;
247	Assert. That( m. SVN == null, "1. SVN should be null" ) ;
248	Assert. That( svn. Angestellter == null, "1. Mitarbeiter should be null" ) ;

249	········}
250
251
252	········[Test]
253	········public void CompTestReplaceChildSave()


254	········{
255	············var pm = PmFactory.NewPersistenceManager();
256	············pm.MakePersistent( m );
257	············m.SVN = svn;
258	············pm.Save();
259	Assert. That( m. SVN != null, "1. SVN not found" ) ;
260	············Sozialversicherungsnummer svn2 = new Sozialversicherungsnummer();
261	············svn2.SVN = 0815;
262	············m.SVN = svn2;
263	Assert. That( NDOObjectState. Deleted == svn. NDOObjectState, "1. Wrong state" ) ;
264	Assert. That( NDOObjectState. Created == svn2. NDOObjectState, "2. Wrong state" ) ;
265	Assert. That( svn. Angestellter == null, "3. No relation to Mitarbeiter" ) ;
266	Assert. That( Object. ReferenceEquals( svn2. Angestellter, m) , "4. Mitarbeiter should be same" ) ;
267	Assert. That( Object. ReferenceEquals( m. SVN, svn2) , "5. SVN should be same" ) ;
268	············pm.Save();
269	Assert. That( NDOObjectState. Transient == svn. NDOObjectState, "6. Wrong state" ) ;
270	Assert. That( NDOObjectState. Persistent == svn2. NDOObjectState, "7. Wrong state" ) ;
271	Assert. That( svn. Angestellter == null, "8. No relation to Mitarbeiter" ) ;
272	Assert. That( Object. ReferenceEquals( svn2. Angestellter, m) , "9. Mitarbeiter should be same" ) ;
273	Assert. That( Object. ReferenceEquals( m. SVN, svn2) , "10. SVN should be same" ) ;
274	········}

275
276	········[Test]
277	········public void CompTestReplaceChildAbort()
278	········{
279	var pm = PmFactory. NewPersistenceManager( ) ;

280	············pm.MakePersistent( m );
281	············m.SVN = svn;
282	Assert. That( Object. ReferenceEquals( svn. Angestellter, m) , "1. Mitarbeiter should be same" ) ;
283	············pm.Save();
284	Assert. That( m. SVN != null, "1. SVN not found" ) ;
285	············Sozialversicherungsnummer svn2 = new Sozialversicherungsnummer();
286	············svn2.SVN = 0815;
287	············m.SVN = svn2;
288	············pm.Abort();
289	Assert. That( NDOObjectState. Transient == svn2. NDOObjectState, "1. Wrong state" ) ;
290	Assert. That( NDOObjectState. Persistent == svn. NDOObjectState, "2. Wrong state" ) ;
291	Assert. That( svn2. Angestellter == null, "3. No relation to Mitarbeiter" ) ;
292	Assert. That( Object. ReferenceEquals( svn. Angestellter, m) , "4. Mitarbeiter should be same" ) ;
293	Assert. That( Object. ReferenceEquals( m. SVN, svn) , "5. SVN should be same" ) ;
294	········}

295
296	········[Test]
297	········public void CompTestReplaceParent()
298	········{
299	var pm = PmFactory. NewPersistenceManager( ) ;

300	············pm.MakePersistent( m );
301	············m.SVN = svn;
302	············pm.Save();
303	Assert. That( m. SVN != null, "1. SVN not found" ) ;
304	············Mitarbeiter m2 = CreateMitarbeiter( "Andre", "Agassi" );
305	············var thrown = false;
306	············try
307	············{
308	················svn.Angestellter = m2;
309	············}
310	············catch (NDOException)
311	············{
312	················thrown = true;


313	············}
314	············Assert.That(true ==··thrown );
315	········}
316
317
318	········[Test]
319	········public void CompTestRemoveObjectSave()
320	········{
321	var pm = PmFactory. NewPersistenceManager( ) ;

322	············pm.MakePersistent( m );
323	············m.SVN = svn;
324	············pm.Save();
325	············ObjectId moid = m.NDOObjectId;
326	Assert. That( m. SVN != null, "1. SVN not found" ) ;
327	············m.SVN = null;
328	Assert. That( NDOObjectState. Deleted == svn. NDOObjectState, "1. Wrong state" ) ;
329	Assert. That( m. SVN == null, "1. SVN should be null" ) ;
330	Assert. That( svn. Angestellter == null, "1. Mitarbeiter should be null" ) ;
331	············pm.Save();
332	Assert. That( m. SVN == null, "2. SVN should be null" ) ;
333	Assert. That( NDOObjectState. Transient == svn. NDOObjectState, "2. Wrong state" ) ;
334	············moid = m.NDOObjectId;
335	············pm.UnloadCache();
336	m = ( Mitarbeiter) pm. FindObject( moid ) ;
337	Assert. That( m != null, "3. Mitarbeiter not found" ) ;
338	Assert. That( m. SVN == null, "3. SVN should be null" ) ;

339	········}
340
341	········[Test]
342	········public void CompTestRemoveObjectAbort()
343	········{
344	var pm = PmFactory. NewPersistenceManager( ) ;

345	············pm.MakePersistent( m );
346	············m.SVN = svn;
347	············pm.Save();
348	Assert. That( m. SVN != null, "1. SVN not found" ) ;
349	············m.SVN = null;
350	Assert. That( NDOObjectState. Deleted == svn. NDOObjectState, "1. Wrong state" ) ;
351	Assert. That( m. SVN == null, "2. SVN should be null" ) ;
352	············pm.Abort();
353	Assert. That( m. SVN != null, "2. SVN not found" ) ;
354	Assert. That( NDOObjectState. Persistent == svn. NDOObjectState, "2. Wrong state" ) ;
355	Assert. That( Object. ReferenceEquals( m, svn. Angestellter) , "2. Backlink wrong" ) ;

356	········}
357
358	········[Test]
359	········public void CompTestRemoveParentSave()


360	········{
361	············var pm = PmFactory.NewPersistenceManager();
362	············pm.MakePersistent( m );
363	············m.SVN = svn;
364	············pm.Save();
365	Assert. That( svn. Angestellter != null, "1. Mitarbeiter not found" ) ;

366	············var thrown = false;
367	············try
368	············{
369	················svn.Angestellter = null;··// Cannot manipulate composition through child object.
370	············}
371	············catch (NDOException)
372	············{
373	················thrown = true;
374	············}
375	Assert. That( true == thrown ) ;

376	········}
377
378
379	········[Test]
380	········public void CompTestDeleteSave()
381	········{
382	var pm = PmFactory. NewPersistenceManager( ) ;

383	············pm.MakePersistent( m );
384	············pm.Save();
385	············m.SVN = svn;
386	············pm.Save();
387	············pm.Delete( m );
388	Assert. That( NDOObjectState. Deleted == m. NDOObjectState, "1. Wrong state" ) ;
389	Assert. That( NDOObjectState. Deleted == svn. NDOObjectState, "2. Wrong state" ) ;
390	············pm.Save();
391	Assert. That( NDOObjectState. Transient == m. NDOObjectState, "1. Wrong state" ) ;
392	Assert. That( NDOObjectState. Transient == svn. NDOObjectState, "2. Wrong state" ) ;

393	············// Objects should retain relations in memory
394	Assert. That( m. SVN != null, "3. SVN shouldn't be null" ) ;
395	Assert. That( svn. Angestellter == null, "3. Mitarbeiter should be null" ) ;

396	········}
397
398	········[Test]
399	········public void CompTestDeleteChildSave()
400	········{
401	var pm = PmFactory. NewPersistenceManager( ) ;

402	············bool thrown = false;
403	············pm.MakePersistent( m );
404	············pm.Save();
405	············m.SVN = svn;
406	············pm.Save();
407	············try
408	············{
409	················pm.Delete( svn ); // Should throw an Exception
410	············}
411	············catch (NDOException e)
412	············{
413	················thrown = true;
414	············}
415	············Assert.That( thrown, "Exception mösste ausgelöst worden sein" );

416	········}
417
418
419	········[Test]
420	········public void CompTestDeleteAbort()
421	········{
422	var pm = PmFactory. NewPersistenceManager( ) ;

423	············pm.MakePersistent( m );
424	············pm.Save();
425	············m.SVN = svn;
426	············pm.Save();
427	············pm.Delete( m );
428	Assert. That( NDOObjectState. Deleted == m. NDOObjectState, "1. Wrong state" ) ;
429	Assert. That( NDOObjectState. Deleted == svn. NDOObjectState, "2. Wrong state" ) ;
430	············pm.Abort();
431	Assert. That( NDOObjectState. Persistent == m. NDOObjectState, "1. Wrong state" ) ;
432	Assert. That( NDOObjectState. Persistent == svn. NDOObjectState, "2. Wrong state" ) ;
433	Assert. That( m. SVN != null, "2. SVN not found" ) ;
434	Assert. That( Object. ReferenceEquals( m, svn. Angestellter) , "2. Backlink wrong" ) ;

435	········}
436
437	········[Test]
438	········public void CompTestCreateDelete()
439	········{
440	var pm = PmFactory. NewPersistenceManager( ) ;

441	············pm.MakePersistent( m );
442	············m.SVN = svn;
443	············pm.Delete( m );
444	Assert. That( NDOObjectState. Transient == m. NDOObjectState, "1. Wrong state" ) ;
445	Assert. That( NDOObjectState. Transient == svn. NDOObjectState, "2. Wrong state" ) ;
446	············// Objects should retain relations in memory
447	Assert. That( m. SVN != null, "3. SVN shouldn't be null" ) ;
448	Assert. That( svn. Angestellter == null, "3. Mitarbeiter should be null" ) ;
449	········}

450
451	········[Test]
452	········public void CompTestAddRemoveSave()
453	········{
454	var pm = PmFactory. NewPersistenceManager( ) ;

455	············pm.MakePersistent( m );
456	············pm.Save();
457	············m.SVN = svn;
458	············m.SVN = null;
459	Assert. That( NDOObjectState. Transient == svn. NDOObjectState, "1. Wrong state" ) ;
460	Assert. That( m. SVN == null, "1. SVN should be null" ) ;
461	Assert. That( svn. Angestellter == null, "1. Mitarbeiter should be null" ) ;
462	············pm.Save();
463	Assert. That( NDOObjectState. Transient == svn. NDOObjectState, "2. Wrong state" ) ;
464	Assert. That( m. SVN == null, "2. SVN should be null" ) ;
465	Assert. That( svn. Angestellter == null, "3. Mitarbeiter should be null" ) ;

466	········}
467
468	········[Test]
469	········public void CompTestAddRemoveAbort()
470	········{
471	var pm = PmFactory. NewPersistenceManager( ) ;

472	············pm.MakePersistent( m );
473	············pm.Save();
474	············m.SVN = svn;
475	············m.SVN = null;
476	Assert. That( NDOObjectState. Transient == svn. NDOObjectState, "1. Wrong state" ) ;
477	············pm.Abort();


478	············Assert.That(NDOObjectState.Transient ==··svn.NDOObjectState, "2. Wrong state" );
479	············Assert.That(m.SVN == null, "2. SVN should be null" );
480	············Assert.That(svn.Angestellter == null, "3. Mitarbeiter should be null" );
481	········}
482
483
484
485	········[Test]
486	········public void CompTestHollow()
487	········{
488	var pm = PmFactory. NewPersistenceManager( ) ;


489	············m.SVN = svn;
490	············pm.MakePersistent( m );
491	············pm.Save();
492	············pm.MakeHollow( m ); // setzt m.svn auf null
493
494	Assert. That( NDOObjectState. Hollow == m. NDOObjectState, "1: Mitarbeiter should be hollow" ) ;
495	Assert. That( NDOObjectState. Persistent == svn. NDOObjectState, "1: SVN should be persistent" ) ;
496
497	············svn = m.SVN; // ruft LoadData för m auf. m.svm liegt auf dem Cache und ist Persistent
498	Assert. That( NDOObjectState. Persistent == m. NDOObjectState, "1: Mitarbeiter should be persistent" ) ;
499	Assert. That( NDOObjectState. Persistent == svn. NDOObjectState, "2: SVN should be persistent" ) ;
500	ObjectId id = m. NDOObjectId;
501	pm. Close( ) ;
502	pm = PmFactory. NewPersistenceManager( ) ;
503	m = ( Mitarbeiter) pm. FindObject( id ) ;
504	Assert. That( m != null, "Mitarbeiter not found" ) ;
505	Assert. That( NDOObjectState. Hollow == m. NDOObjectState, "2: Mitarbeiter should be hollow" ) ;


506	············svn = m.SVN;
507	Assert. That( NDOObjectState. Persistent == m. NDOObjectState, "2: Mitarbeiter should be persistent" ) ;
508	Assert. That( svn != null, "SVN not found" ) ;
509	Assert. That( NDOObjectState. Hollow == svn. NDOObjectState, "1: SVN should be hollow" ) ;
510	Assert. That( Object. ReferenceEquals( m, svn. Angestellter) , "2. Backlink wrong" ) ;

511	········}
512
513
514	········[Test]
515	········public void CompTestMakeAllHollow()
516	········{
517	var pm = PmFactory. NewPersistenceManager( ) ;

518	············m.SVN = svn;
519	············pm.MakePersistent( m );
520	············pm.Save();
521	············pm.MakeAllHollow();
522	Assert. That( NDOObjectState. Hollow == m. NDOObjectState, "1: Mitarbeiter should be hollow" ) ;
523	Assert. That( NDOObjectState. Hollow == svn. NDOObjectState, "1: SVN should be hollow" ) ;
524	Assert. That( Object. ReferenceEquals( m, svn. Angestellter) , "2. Backlink wrong" ) ;

525	········}
526
527	········[Test]
528	········public void CompTestMakeAllHollowUnsaved()
529	········{
530	var pm = PmFactory. NewPersistenceManager( ) ;

531	············m.SVN = svn;
532	············pm.MakePersistent( m );
533	············pm.MakeAllHollow();··// before save, objects cannot be made hollow. => in locked objects
534	Assert. That( NDOObjectState. Created == m. NDOObjectState, "1: Mitarbeiter should be created" ) ;
535	Assert. That( NDOObjectState. Created == svn. NDOObjectState, "1: SVN should be created" ) ;

536	········}
537
538	········[Test]
539	········public void CompTestLockRelations()
540	········{
541	var pm = PmFactory. NewPersistenceManager( ) ;

542	············m.SVN = svn;
543	············pm.MakePersistent( m );
544	············m.Adresse = new Adresse();
545	············m.Adresse.Lkz = "Bla";
546	············pm.Save();
547	············pm.Delete( m );
548	············pm.Save();
549	Assert. That( NDOObjectState. Transient == m. NDOObjectState, "1: mitarbeiter should be transient" ) ;
550	Assert. That( NDOObjectState. Transient == m. SVN. NDOObjectState, "1: SVN should be transient" ) ;
551	Assert. That( NDOObjectState. Transient == m. Adresse. NDOObjectState, "1: Adresse should be transient" ) ;

552	········}
553
554	········[Test]
555	········public void CompTestExtentRelatedObjects()
556	········{
557	var pm = PmFactory. NewPersistenceManager( ) ;

558	············m.SVN = svn;
559	············pm.MakePersistent( m );
560	············pm.Save();
561	············IList liste = pm.GetClassExtent( typeof( Mitarbeiter ) );
562	m = ( Mitarbeiter) liste[0];
563	Assert. That( NDOObjectState. Persistent == m. NDOObjectState, "1: Mitarbeiter should be persistent" ) ;
564	Assert. That( m. SVN != null, "2. Relation is missing" ) ;
565	Assert. That( NDOObjectState. Persistent == m. SVN. NDOObjectState, "2. : SVN should be hollow" ) ;
566	Assert. That( Object. ReferenceEquals( m, svn. Angestellter) , "2. Backlink wrong" ) ;
567
568	············pm.UnloadCache();
569	············liste = pm.GetClassExtent( typeof( Mitarbeiter ) );
570	m = ( Mitarbeiter) liste[0];
571	Assert. That( NDOObjectState. Hollow == m. NDOObjectState, "5: Mitarbeiter should be hollow" ) ;
572	Assert. That( m. SVN != null, "6. Relation is missing" ) ;
573	Assert. That( NDOObjectState. Hollow == m. SVN. NDOObjectState, "8. : SVN should be hollow" ) ;
574	············Assert.That( m != svn.Angestellter, "8a. Should be different objects" );
575	Assert. That( Object. ReferenceEquals( m, m. SVN. Angestellter) , "8b. Mitarbeiter should match" ) ;
576
577	············pm.UnloadCache();
578	············liste = pm.GetClassExtent( typeof( Mitarbeiter ), false );
579	m = ( Mitarbeiter) liste[0];
580	Assert. That( NDOObjectState. Persistent == m. NDOObjectState, "9: Mitarbeiter should be persistent" ) ;
581	Assert. That( m. SVN != null, "10. Relation is missing" ) ;
582	Assert. That( NDOObjectState. Hollow == m. SVN. NDOObjectState, "12. : SVN should be hollow" ) ;
583	············Assert.That( m != svn.Angestellter, "12a. Should be different objects" );
584	Assert. That( Object. ReferenceEquals( m, m. SVN. Angestellter) , "12b. Mitarbeiter should match" ) ;
585	········}

586
587	········#endregion
588
589	········#region Aggregation Tests
590
591	········[Test]
592	········public void AggrTestCreateObjectsTransient()
593	········{
594	var pm = PmFactory. NewPersistenceManager( ) ;

595	············e.Schlüssel = z0;
596	············var thrown = false;
597	············try
598	············{
599	················pm.MakePersistent( e );
600	············}
601	············catch (NDOException)
602	············{
603	················thrown = true;
604	············}
605	Assert. That( true == thrown ) ;
606	········}

607
608	········[Test]
609	········public void AggrTestCreateObjectsTransient2()


610	········{
611	············var pm = PmFactory.NewPersistenceManager();
612	············pm.MakePersistent( e );
613	············var thrown = false;
614	············try
615	············{
616	················e.Schlüssel = z0;
617	············}
618	············catch (NDOException)
619	············{
620	················thrown = true;
621	············}
622	Assert. That( true == thrown ) ;
623	········}

624
625	········[Test]
626	········public void AggrTestCreateObjectsSave()


627	········{
628	············var pm = PmFactory.NewPersistenceManager();
629	············pm.MakePersistent( z0 );
630	············e.Schlüssel = z0;
631	············pm.MakePersistent( e );
632	············pm.Save();
633	············Assert.That( !e.NDOObjectId.Equals( e.Schlüssel.NDOObjectId ), "Ids should be different" );
634	e = ( Email) pm. FindObject( e. NDOObjectId ) ;
635	z0 = ( Zertifikat) pm. FindObject( e. Schlüssel. NDOObjectId ) ;
636	Assert. That( e != null, "1. Email not found" ) ;
637	Assert. That( z0 != null, "1. Zertifikat not found" ) ;
638	············ObjectId moid = e.NDOObjectId;
639	············ObjectId soid = z0.NDOObjectId;
640	············e = null;
641	············z0 = null;
642
643	············pm.UnloadCache();
644	e = ( Email) pm. FindObject( moid ) ;
645	············var z1 = pm.Objects<Zertifikat>().Where(z=>z.Oid() == soid.Id.Value).SingleOrDefault();
646	············Assert.That( z1 != null );
647	············Zertifikat z2 = e.Schlüssel;
648	Assert. That( Object. ReferenceEquals( z1, z2) ) ;
649	z0 = ( Zertifikat) pm. FindObject( soid ) ;
650	Assert. That( e != null, "2. Email not found" ) ;
651	Assert. That( z0 != null, "2. Zertifikat not found" ) ;
652	Assert. That( Object. ReferenceEquals( z0, z2) , "Zertifikat should match" ) ;
653	Assert. That( Object. ReferenceEquals( e, z0. Adresse) , "Email should match" ) ;

654	········}
655
656	········[Test]
657	········public void AggrTestCreateObjectsWithTransaction()
658	········{
659	var pm = PmFactory. NewPersistenceManager( ) ;

660	············var tm = pm.TransactionMode;
661	············try
662	············{
663	················// See Issue #1145
664	················// The test would fail, if we didn't alter the update rank
665	················// according to the actual situation, that e has a valid database id.
666	················// The test would fail, because the update rank would cause e to be saved first
667	················// at the 2nd Save() call.
668	················pm.TransactionMode = TransactionMode.Optimistic;
669	················pm.MakePersistent( e );
670	················pm.Save( true );
671	················pm.MakePersistent( z0 );
672	················e.Schlüssel = z0;
673	················pm.Save();
674	················pm.UnloadCache();
675	················pm.TransactionMode = TransactionMode.None;
676	················var email = pm.Objects<Email>().Single();
677	Assert. That( email. Schlüssel != null) ;
678	Assert. That( 42 == email. Schlüssel. Key ) ;
679	················pm.UnloadCache();
680	················var zertifikat = pm.Objects<Zertifikat>().Single();
681	Assert. That( zertifikat. Adresse != null) ;
682	············}
683	············finally
684	············{
685	················pm.TransactionMode = tm;
686	············}
687	········}

688
689
690	········[Test]
691	········public void AggrSimpleObjectSave()
692	········{
693	var pm = PmFactory. NewPersistenceManager( ) ;

694	············pm.MakePersistent( z0 );
695	············pm.Save();

696	········}
697
698	········[Test]
699	········public void AggrChildAddFail()
700	········{
701	var pm = PmFactory. NewPersistenceManager( ) ;

702	············pm.MakePersistent( z0 );
703	············pm.MakePersistent( e );
704	············z0.Adresse = e;
705	········}

706
707	········[Test]
708	········public void AggrChildAddFail2()
709	········{
710	var pm = PmFactory. NewPersistenceManager( ) ;

711	············pm.MakePersistent( e );
712	············pm.MakePersistent( z0 );
713	············pm.Save();
714	············z0.Adresse = e;
715	········}

716
717	········[Test]
718	········public void AggrChildAdd3()
719	········{
720	var pm = PmFactory. NewPersistenceManager( ) ;

721	············pm.MakePersistent( e );
722	············pm.MakePersistent( z0 );
723	············pm.Save();
724	············e.Schlüssel = z0;
725	············z0.Adresse = e;

726	········}
727
728	········[Test]
729	········public void AggrChildAdd4()
730	········{
731	var pm = PmFactory. NewPersistenceManager( ) ;

732	············pm.MakePersistent( z0 );
733	············pm.MakePersistent( e );
734	············pm.Save();
735	············e.Schlüssel = z0;
736	············z0.Adresse = null;
737	········}

738
739	········[Test]
740	········public void AggrTestAddObjectSave()
741	········{
742	var pm = PmFactory. NewPersistenceManager( ) ;

743	············pm.MakePersistent( z0 );
744	············pm.MakePersistent( e );
745	············pm.Save();
746	············e.Schlüssel = z0;
747	Assert. That( NDOObjectState. PersistentDirty == z0. NDOObjectState, "1. Wrong state" ) ;
748	Assert. That( Object. ReferenceEquals( e, z0. Adresse) , "1. Backlink wrong" ) ;
749	············pm.Save();
750	e = ( Email) pm. FindObject( e. NDOObjectId ) ;
751	z0 = ( Zertifikat) pm. FindObject( z0. NDOObjectId ) ;
752	Assert. That( e != null, "1. Email not found" ) ;
753	Assert. That( z0 != null, "1. Zertifikat not found" ) ;
754	Assert. That( NDOObjectState. Persistent == z0. NDOObjectState, "2. Wrong state" ) ;
755	Assert. That( Object. ReferenceEquals( e, z0. Adresse) , "2. Backlink wrong" ) ;

756	········}
757
758	········[Test]
759	········public void AggrTestAddObjectAbort()
760	········{
761	var pm = PmFactory. NewPersistenceManager( ) ;

762	············pm.MakePersistent( z0 );
763	············pm.MakePersistent( e );
764	············pm.Save();
765	············e.Schlüssel = z0;
766	Assert. That( NDOObjectState. PersistentDirty == z0. NDOObjectState, "1. Wrong state" ) ;
767	Assert. That( e. Schlüssel != null, "1. Zertifikat not found" ) ;
768	············pm.Abort();
769	Assert. That( NDOObjectState. Persistent == z0. NDOObjectState, "2. Wrong state" ) ;
770	Assert. That( e. Schlüssel == null, "1. Zertifikat should be null" ) ;
771	Assert. That( z0. Adresse == null, "1. Email should be null" ) ;

772	········}
773
774
775	········[Test]
776	········public void AggrTestReplaceChildSave()
777	········{
778	var pm = PmFactory. NewPersistenceManager( ) ;

779	············pm.MakePersistent( z0 );
780	············pm.MakePersistent( e );
781	············e.Schlüssel = z0;
782	············pm.Save();
783	Assert. That( e. Schlüssel != null, "1. Zertifikat not found" ) ;
784	············Zertifikat z2 = new Zertifikat();
785	············z2.Key = 0815;
786	············pm.MakePersistent( z2 );
787	············e.Schlüssel = z2;
788	Assert. That( NDOObjectState. PersistentDirty == z0. NDOObjectState, "1. Wrong state" ) ;
789	Assert. That( NDOObjectState. Created == z2. NDOObjectState, "2. Wrong state" ) ;
790	Assert. That( z0. Adresse == null, "3. No relation to Email" ) ;
791	Assert. That( Object. ReferenceEquals( z2. Adresse, e) , "4. Email should be same" ) ;
792	Assert. That( Object. ReferenceEquals( e. Schlüssel, z2) , "5. Zertifikat should be same" ) ;
793	············pm.Save();
794	Assert. That( NDOObjectState. Persistent == z0. NDOObjectState, "6. Wrong state" ) ;
795	Assert. That( NDOObjectState. Persistent == z2. NDOObjectState, "7. Wrong state" ) ;
796	Assert. That( z0. Adresse == null, "8. No relation to Email" ) ;
797	Assert. That( Object. ReferenceEquals( z2. Adresse, e) , "9. Email should be same" ) ;
798	Assert. That( Object. ReferenceEquals( e. Schlüssel, z2) , "10. Zertifikat should be same" ) ;
799	········}

800
801	········[Test]
802	········public void AggrTestReplaceChildAbort()
803	········{
804	var pm = PmFactory. NewPersistenceManager( ) ;

805	············pm.MakePersistent( z0 );
806	············pm.MakePersistent( e );
807	············e.Schlüssel = z0;
808	············pm.Save();
809	Assert. That( e. Schlüssel != null, "1. Zertifikat not found" ) ;
810	············Zertifikat z2 = new Zertifikat();
811	············z2.Key = 0815;
812	············pm.MakePersistent( z2 );
813	············e.Schlüssel = z2;
814	············pm.Abort();
815	Assert. That( NDOObjectState. Transient == z2. NDOObjectState, "1. Wrong state" ) ;
816	Assert. That( NDOObjectState. Persistent == z0. NDOObjectState, "2. Wrong state" ) ;
817	Assert. That( z2. Adresse == null, "3. No relation to Email" ) ;
818	Assert. That( Object. ReferenceEquals( z0. Adresse, e) , "4. Email should be same" ) ;
819	Assert. That( Object. ReferenceEquals( e. Schlüssel, z0) , "5. Zertifikat should be same" ) ;

820	········}
821
822	········[Test]
823	········public void AggrTestReplaceParentSave()
824	········{
825	var pm = PmFactory. NewPersistenceManager( ) ;

826	············pm.MakePersistent( z0 );
827	············pm.MakePersistent( e );
828	············e.Schlüssel = z0;
829	············pm.Save();
830	Assert. That( e. Schlüssel != null, "1. Zertifikat not found" ) ;
831	············Email m2 = new Email( "db@cortex-brainware.de" );
832	············pm.MakePersistent( m2 );
833	············z0.Adresse = m2;
834	········}

835
836
837	········[Test]
838	········public void AggrTestRemoveObjectSave()
839	········{
840	var pm = PmFactory. NewPersistenceManager( ) ;

841	············pm.MakePersistent( z0 );
842	············pm.MakePersistent( e );
843	············e.Schlüssel = z0;
844	············pm.Save();
845	Assert. That( e. Schlüssel != null, "1. Zertifikat not found" ) ;
846	············ObjectId aoid = z0.NDOObjectId;
847	············e.Schlüssel = null;
848	Assert. That( NDOObjectState. PersistentDirty == z0. NDOObjectState, "1. Wrong state" ) ;
849	Assert. That( e. Schlüssel == null, "1. Zertifikat should be null" ) ;
850	Assert. That( z0. Adresse == null, "1. Email should be null" ) ;
851	············pm.Save();
852	Assert. That( e. Schlüssel == null, "2. Zertifikat should be null" ) ;
853	Assert. That( NDOObjectState. Persistent == z0. NDOObjectState, "2. Wrong state" ) ;
854	············ObjectId moid = e.NDOObjectId;
855	············Assert.That( aoid.IsValid(), "Still valid Zertifikat" );
856	············pm.UnloadCache();
857	e = ( Email) pm. FindObject( moid ) ;
858	Assert. That( e != null, "3. Email not found" ) ;
859	Assert. That( e. Schlüssel == null, "3. Zertifikat should be null" ) ;

860	········}
861
862	········[Test]
863	········public void AggrTestRemoveObjectAbort()
864	········{
865	var pm = PmFactory. NewPersistenceManager( ) ;

866	············pm.MakePersistent( z0 );
867	············pm.MakePersistent( e );
868	············e.Schlüssel = z0;
869	············pm.Save();
870	Assert. That( e. Schlüssel != null, "1. Zertifikat not found" ) ;
871	············e.Schlüssel = null;
872	Assert. That( NDOObjectState. PersistentDirty == z0. NDOObjectState, "1. Wrong state" ) ;
873	Assert. That( e. Schlüssel == null, "2. Zertifikat should be null" ) ;
874	············pm.Abort();
875	Assert. That( e. Schlüssel != null, "2. Zertifikat not found" ) ;
876	Assert. That( NDOObjectState. Persistent == z0. NDOObjectState, "2. Wrong state" ) ;
877	Assert. That( Object. ReferenceEquals( e, z0. Adresse) , "2. Backlink wrong" ) ;

878	········}
879
880	········[Test]
881	········public void AggrTestRemoveParentSave()
882	········{
883	var pm = PmFactory. NewPersistenceManager( ) ;

884	············pm.MakePersistent( z0 );
885	············pm.MakePersistent( e );
886	············e.Schlüssel = z0;
887	············pm.Save();
888	Assert. That( z0. Adresse != null, "1. Email not found" ) ;
889	············ObjectId aoid = z0.NDOObjectId;
890	············z0.Adresse = null;
891	Assert. That( NDOObjectState. PersistentDirty == z0. NDOObjectState, "1. Wrong state" ) ;
892	Assert. That( e. Schlüssel == null, "1. Zertifikat should be null" ) ;
893	Assert. That( z0. Adresse == null, "1. Email should be null" ) ;
894	············pm.Save();
895	Assert. That( e. Schlüssel == null, "2. Zertifikat should be null" ) ;
896	Assert. That( NDOObjectState. Persistent == z0. NDOObjectState, "2. Wrong state" ) ;
897	············ObjectId moid = e.NDOObjectId;
898	············Assert.That( aoid.IsValid(), "Zertifikat still valid" );
899	············pm.UnloadCache();
900	e = ( Email) pm. FindObject( moid ) ;
901	Assert. That( e != null, "3. Email not found" ) ;
902	Assert. That( e. Schlüssel == null, "3. Zertifikat should be null" ) ;

903	········}
904
905	········[Test]
906	········public void AggrTestRemoveParentAbort()
907	········{
908	var pm = PmFactory. NewPersistenceManager( ) ;

909	············pm.MakePersistent( z0 );
910	············pm.MakePersistent( e );
911	············e.Schlüssel = z0;
912	············pm.Save();
913	Assert. That( e. Schlüssel != null, "1. Zertifikat not found" ) ;
914	············z0.Adresse = null;
915	Assert. That( NDOObjectState. PersistentDirty == z0. NDOObjectState, "1. Wrong state" ) ;
916	Assert. That( e. Schlüssel == null, "2. Zertifikat should be null" ) ;
917	············pm.Abort();
918	Assert. That( e. Schlüssel != null, "2. Zertifikat not found" ) ;
919	Assert. That( NDOObjectState. Persistent == z0. NDOObjectState, "2. Wrong state" ) ;
920	Assert. That( Object. ReferenceEquals( e, z0. Adresse) , "2. Backlink wrong" ) ;
921	········}
922
923	#if false
924	········[Test]
925	········[ExpectedException(typeof(NDOException))]
926	········public void AggrTestDelete () {
927	············pm.MakePersistent(z);
928	············pm.MakePersistent(e);
929	············pm.Save();
930	············e.Schlüssel = z;
931	············pm.Save();
932	············pm.Delete(e);··// Cannot delete object within aggregation
933	········}
934
935
936	········[Test]
937	········[ExpectedException(typeof(NDOException))]
938	········public void AggrTestCreateDelete() {
939	············pm.MakePersistent(z);
940	············pm.MakePersistent(e);
941	············e.Schlüssel = z;
942	············pm.Delete(e);··// Cannot delete object within aggregation
943	········}
944	#endif
945
946	········[Test]
947	········public void AggrTestCreateDeleteAllowed()
948	········{
949	var pm = PmFactory. NewPersistenceManager( ) ;

950	············pm.MakePersistent( z0 );
951	············pm.MakePersistent( e );
952	············e.Schlüssel = z0;
953	············e.Schlüssel = null;
954	············pm.Delete( e );
955	Assert. That( NDOObjectState. Created == z0. NDOObjectState, "1. Wrong state" ) ;
956	Assert. That( NDOObjectState. Transient == e. NDOObjectState, "2. Wrong state" ) ;
957	Assert. That( e. Schlüssel == null, "3. Zertifikat should be null" ) ;
958	Assert. That( z0. Adresse == null, "4. Email should be null" ) ;

959	········}
960
961
962	········[Test]
963	········public void AggrTestAddRemoveSave()
964	········{
965	var pm = PmFactory. NewPersistenceManager( ) ;

966	············pm.MakePersistent( e );
967	············pm.MakePersistent( z0 );
968	············pm.Save();
969	············e.Schlüssel = z0;
970	············e.Schlüssel = null;
971	Assert. That( NDOObjectState. PersistentDirty == z0. NDOObjectState, "1. Wrong state" ) ;
972	Assert. That( e. Schlüssel == null, "1. Zertifikat should be null" ) ;
973	Assert. That( z0. Adresse == null, "1. Email should be null" ) ;
974	············pm.Save();
975	Assert. That( NDOObjectState. Persistent == z0. NDOObjectState, "2. Wrong state" ) ;
976	Assert. That( e. Schlüssel == null, "2. Zertifikat should be null" ) ;
977	Assert. That( z0. Adresse == null, "3. Email should be null" ) ;

978	········}
979
980	········[Test]
981	········public void AggrTestAddRemoveAbort()
982	········{
983	var pm = PmFactory. NewPersistenceManager( ) ;

984	············pm.MakePersistent( e );
985	············pm.MakePersistent( z0 );
986	············pm.Save();
987	············e.Schlüssel = z0;
988	············e.Schlüssel = null;
989	Assert. That( NDOObjectState. PersistentDirty == z0. NDOObjectState, "1. Wrong state" ) ;
990	············pm.Abort();
991	Assert. That( NDOObjectState. Persistent == z0. NDOObjectState, "2. Wrong state" ) ;
992	Assert. That( e. Schlüssel == null, "2. Zertifikat should be null" ) ;
993	Assert. That( z0. Adresse == null, "3. Email should be null" ) ;

994	········}
995
996
997
998	········[Test]
999	········public void AggrTestHollow()
1000	········{
1001	var pm = PmFactory. NewPersistenceManager( ) ;


1002	············pm.MakePersistent( z0 );
1003	············e.Schlüssel = z0;
1004	············pm.MakePersistent( e );
1005	············pm.Save();
1006	············pm.MakeHollow( e ); // setzt e.z auf null
1007
1008	Assert. That( NDOObjectState. Hollow == e. NDOObjectState, "1: Email should be hollow" ) ;
1009	Assert. That( NDOObjectState. Persistent == z0. NDOObjectState, "1: Zertifikat should be persistent" ) ;
1010
1011	············z0 = e.Schlüssel; // ruft LoadData för e auf. e.svm liegt auf dem Cache und ist Persistent
1012	Assert. That( NDOObjectState. Persistent == e. NDOObjectState, "1: Email should be persistent" ) ;
1013	Assert. That( NDOObjectState. Persistent == z0. NDOObjectState, "2: Zertifikat should be persistent" ) ;
1014	ObjectId id = e. NDOObjectId;
1015	pm. Close( ) ;
1016	pm = PmFactory. NewPersistenceManager( ) ;
1017	e = ( Email) pm. FindObject( id ) ;
1018	Assert. That( e != null, "Email not found" ) ;
1019	Assert. That( NDOObjectState. Hollow == e. NDOObjectState, "2: Email should be hollow" ) ;

1020	············z0 = e.Schlüssel;
1021	Assert. That( NDOObjectState. Persistent == e. NDOObjectState, "2: Email should be persistent" ) ;
1022	Assert. That( z0 != null, "Zertifikat not found" ) ;
1023	Assert. That( NDOObjectState. Hollow == z0. NDOObjectState, "1: Zertifikat should be hollow" ) ;
1024	Assert. That( Object. ReferenceEquals( e, z0. Adresse) , "2. Backlink wrong" ) ;

1025	········}
1026
1027
1028	········[Test]
1029	········public void AggrTestMakeAllHollowDelete()
1030	········{
1031	var pm = PmFactory. NewPersistenceManager( ) ;

1032	············pm.MakePersistent( z0 );
1033	············e.Schlüssel = z0;
1034	············pm.MakePersistent( e );
1035	············pm.Save();
1036	············pm.MakeAllHollow();
1037	Assert. That( NDOObjectState. Hollow == e. NDOObjectState, "1: Email should be hollow" ) ;
1038	Assert. That( NDOObjectState. Hollow == z0. NDOObjectState, "1: Zertifikat should be hollow" ) ;
1039	············Zertifikat zz = e.Schlüssel;··// Das lödt das Objekt, deshalb geht es hier!
1040	············e.Schlüssel = null;
1041	Assert. That( NDOObjectState. PersistentDirty == e. NDOObjectState, "2: Email should be persistent dirty" ) ;
1042	Assert. That( NDOObjectState. PersistentDirty == z0. NDOObjectState, "2: Zertifikat should be persistent dirty" ) ;
1043	Assert. That( e. Schlüssel == null, "3. Email should have no Zertifikat" ) ;
1044	Assert. That( z0. Adresse == null, "3. Zertifikat should have no Email" ) ;
1045	············pm.Delete( e );
1046	········}

1047
1048	········[Test]
1049	········public void AggrTestMakeAllHollow()
1050	········{
1051	var pm = PmFactory. NewPersistenceManager( ) ;

1052	············pm.MakePersistent( z0 );
1053	············e.Schlüssel = z0;
1054	············pm.MakePersistent( e );
1055	············pm.Save();
1056	············pm.MakeAllHollow();
1057	Assert. That( NDOObjectState. Hollow == e. NDOObjectState, "1: Email should be hollow" ) ;
1058	Assert. That( NDOObjectState. Hollow == z0. NDOObjectState, "1: Zertifikat should be hollow" ) ;
1059	Assert. That( Object. ReferenceEquals( e, z0. Adresse) , "2. Backlink wrong" ) ;

1060	········}
1061
1062	········[Test]
1063	········public void AggrTestMakeAllHollowUnsaved()
1064	········{
1065	var pm = PmFactory. NewPersistenceManager( ) ;

1066	············pm.MakePersistent( z0 );
1067	············e.Schlüssel = z0;
1068	············pm.MakePersistent( e );
1069	············pm.MakeAllHollow();··// before save, objects cannot be made hollow. => in locked objects
1070	Assert. That( NDOObjectState. Created == e. NDOObjectState, "1: Email should be created" ) ;
1071	Assert. That( NDOObjectState. Created == z0. NDOObjectState, "1: Zertifikat should be created" ) ;

1072	········}
1073
1074
1075	········[Test]
1076	········public void AggrTestExtentRelatedObjects()
1077	········{
1078	var pm = PmFactory. NewPersistenceManager( ) ;

1079	············pm.MakePersistent( z0 );
1080	············e.Schlüssel = z0;
1081	············pm.MakePersistent( e );
1082	············pm.Save();
1083	············IList liste = pm.GetClassExtent( typeof( Email ) );
1084	e = ( Email) liste[0];
1085	Assert. That( NDOObjectState. Persistent == e. NDOObjectState, "1: Email should be persistent" ) ;
1086	Assert. That( e. Schlüssel != null, "2. Relation is missing" ) ;
1087	Assert. That( NDOObjectState. Persistent == e. Schlüssel. NDOObjectState, "2. : Zertifikat should be hollow" ) ;
1088	Assert. That( Object. ReferenceEquals( e, z0. Adresse) , "2. Backlink wrong" ) ;
1089
1090	············pm.UnloadCache();
1091	············liste = pm.GetClassExtent( typeof( Email ) );
1092	e = ( Email) liste[0];
1093	Assert. That( NDOObjectState. Hollow == e. NDOObjectState, "5: Email should be hollow" ) ;
1094	Assert. That( e. Schlüssel != null, "6. Relation is missing" ) ;
1095	Assert. That( NDOObjectState. Hollow == e. Schlüssel. NDOObjectState, "8. : Zertifikat should be hollow" ) ;
1096	············Assert.That( e != z0.Adresse, "8a. Should be different objects" );
1097	Assert. That( Object. ReferenceEquals( e, e. Schlüssel. Adresse) , "8b. Email should match" ) ;
1098
1099	············pm.UnloadCache();
1100	············liste = pm.GetClassExtent( typeof( Email ), false );
1101	e = ( Email) liste[0];
1102	Assert. That( NDOObjectState. Persistent == e. NDOObjectState, "9: Email should be persistent" ) ;
1103	Assert. That( e. Schlüssel != null, "10. Relation is missing" ) ;
1104	Assert. That( NDOObjectState. Hollow == e. Schlüssel. NDOObjectState, "12. : Zertifikat should be hollow" ) ;
1105	············Assert.That( e != z0.Adresse, "12a. Should be different objects" );
1106	Assert. That( Object. ReferenceEquals( e, e. Schlüssel. Adresse) , "12b. Email should match" ) ;

1107	········}
1108
1109	········[Test]
1110	········public void BiTest()


1111	········{
1112	············var pm = PmFactory.NewPersistenceManager();
1113	············pm.MakePersistent( e );
1114	············pm.MakePersistent( z0 );
1115	············//············System.Diagnostics.Debug.WriteLine("e:" + e.NDOObjectId.ExpressionString);
1116	············//············System.Diagnostics.Debug.WriteLine("z:" + z.NDOObjectId.ExpressionString);
1117	············e.Schlüssel = this.z0;
1118	············pm.Save();
1119	············//············System.Diagnostics.Debug.WriteLine("e:" + e.NDOObjectId.ExpressionString);
1120	············//············System.Diagnostics.Debug.WriteLine("z:" + z.NDOObjectId.ExpressionString);
1121

1122	········}
1123
1124
1125	········#endregion
1126
1127	········private void SetupEmail()
1128	········{
1129	············var pm = PmFactory.NewPersistenceManager();
1130	············pm.MakePersistent( e );
1131	············pm.Save();
1132	········}
1133
1134	········private Mitarbeiter CreateMitarbeiter( string vorname, string nachname )
1135	········{
1136	············Mitarbeiter m = new Mitarbeiter();
1137	············m.Vorname = vorname;
1138	············m.Nachname = nachname;
1139	············return m;
1140	········}
1141	····}
1142	}
1143

New Commit (60aa080)

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
32	namespace NdoUnitTests
33	{
34	····/// <summary>
35	····/// All tests for 1:1-Relations. Bidirectional Composition and Aggregation
36	····/// </summary>
37
38
39	····[TestFixture]
40	····public class Rel1to1Bidirectional : NDOTest
41	····{
42	········public Rel1to1Bidirectional()
43	········{
44	········}
45
46	········private static int count = 0;
47	········private Mitarbeiter m;
48	········private Sozialversicherungsnummer svn;
49	········private Email e;
50	········private Zertifikat z0;
51
52	········[SetUp]
53	········public void Setup()
54	········{
55	············count++;
56	············m = CreateMitarbeiter( "Boris", "Becker" );
57	············svn = new Sozialversicherungsnummer();
58	············svn.SVN = 4711;
59	············e = new Email( "hwk@cortex-brainware.de" );
60	············z0 = new Zertifikat();
61	············z0.Key = 42; // :-)
62	········}
63
64	········public void DeleteAll()
65	········{
66	············var pm = PmFactory.NewPersistenceManager();
67	············IList mitarbeiterListe = pm.GetClassExtent( typeof( Mitarbeiter ), true );
68	············pm.Delete( mitarbeiterListe );
69	············pm.Save();
70
71	············// Delete unbound Soz.V. objects
72	············IList sozListe = pm.GetClassExtent( typeof( Sozialversicherungsnummer ) );
73	············pm.Delete( sozListe );
74	············pm.Save();
75
76	············IList eListe = pm.GetClassExtent( typeof( Email ) );
77	············pm.Delete( eListe );
78	············pm.Save();
79
80	············IList zListe = pm.GetClassExtent( typeof( Zertifikat ) );
81	············pm.Delete( zListe );
82	············pm.Save();
83	············pm.Close();
84	········}
85
86	········[TearDown]
87	········public void TearDown()
88	········{

89	············DeleteAll();


90	········}
91
92
93
94	········#region Composition Tests
95
96	········[Test]
97	········public void CompTestCreateObjectsSave()
98	········{
99	using ( var pm = PmFactory. NewPersistenceManager( ) )
100	············{
101	················m.SVN = svn;
102	················pm.MakePersistent( m );
103	················pm.Save();
104	················Assert.That( !m.NDOObjectId.Equals( m.SVN.NDOObjectId ), "Ids should be different" );
105	m = ( Mitarbeiter) pm. FindObject( m. NDOObjectId ) ;
106	svn = ( Sozialversicherungsnummer) pm. FindObject( m. SVN. NDOObjectId ) ;
107	Assert. That( m != null, "1. Mitarbeiter not found" ) ;
108	Assert. That( svn != null, "1. SVN not found" ) ;
109	················ObjectId moid = m.NDOObjectId;
110	················ObjectId soid = svn.NDOObjectId;
111	················m = null;
112	················svn = null;
113
114	················pm.UnloadCache();
115	m = ( Mitarbeiter) pm. FindObject( moid ) ;
116	················Sozialversicherungsnummer s2 = m.SVN;
117	svn = ( Sozialversicherungsnummer) pm. FindObject( soid ) ;
118	Assert. That( m != null, "2. Mitarbeiter not found" ) ;
119	Assert. That( svn != null, "2. SVN not found" ) ;
120	Assert. That( Object. ReferenceEquals( svn, s2 ) , "SVN should match" ) ;
121	Assert. That( Object. ReferenceEquals( m, svn. Angestellter ) , "Mitarbeiter should match" ) ;
122	············}
123	········}
124
125	········[Test]
126	········public void SimpleObjectSave()
127	········{
128	using ( var pm = PmFactory. NewPersistenceManager( ) )
129	············{
130	················pm.MakePersistent( svn );
131	················pm.Save();
132	················pm.UnloadCache();
133	················IList l = pm.GetClassExtent( typeof( Sozialversicherungsnummer ) );
134	················Assert.That( l.Count == 1, "Sozialversicherungsnummer sollte gespeichert sein" );
135	················pm.Delete( l );
136	················pm.Save();
137	················pm.UnloadCache();
138	················l = pm.GetClassExtent( typeof( Sozialversicherungsnummer ) );
139	················Assert.That( l.Count == 0, "Sozialversicherungsnummer sollte gelöscht sein" );
140	············}
141	········}
142
143	········[Test]
144	········public void CompChildAddFail()
145	········{
146	using ( var pm = PmFactory. NewPersistenceManager( ) )
147	············{
148	················pm.MakePersistent( svn );
149	················var thrown = false;
150	················try
151	················{
152	····················svn.Angestellter = m;
153	················}
154	················catch (NDOException)
155	················{
156	····················thrown = true;
157	················}
158	Assert. That( true == thrown ) ;
159	············}
160	········}
161
162	········[Test]
163	········public void CompChildAddFail2()
164	········{
165	using ( var pm = PmFactory. NewPersistenceManager( ) )
166	············{
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
182	········[Test]
183	········public void CompChildAdd3()
184	········{
185	using ( var pm = PmFactory. NewPersistenceManager( ) )
186	············{
187	················pm.MakePersistent( m );
188	················pm.Save();
189	················m.SVN = svn;
190	················var thrown = false;
191	················try
192	················{
193	····················svn.Angestellter = m;
194	················}
195	················catch (NDOException)
196	················{
197	····················thrown = true;
198	················}
199	Assert. That( true == thrown ) ;
200	············}
201	········}
202
203	········[Test]
204	········public void CompChildAdd4()
205	········{
206	using ( var pm = PmFactory. NewPersistenceManager( ) )
207	············{
208	················pm.MakePersistent( m );
209	················pm.Save();
210	················m.SVN = svn;
211	················var thrown = false;
212	················try
213	················{
214	····················svn.Angestellter = null; // Cannot change relation through child
215	················}
216	················catch (NDOException)
217	················{
218	····················thrown = true;
219	················}
220	Assert. That( true == thrown ) ;
221	············}
222	········}
223
224	········[Test]
225	········public void CompTestAddObjectSave()
226	········{
227	using ( var pm = PmFactory. NewPersistenceManager( ) )
228	············{
229	················pm.MakePersistent( m );
230	················pm.Save();
231	················m.SVN = svn;
232	Assert. That( NDOObjectState. Created == svn. NDOObjectState, "1. Wrong state" ) ;
233	Assert. That( Object. ReferenceEquals( m, svn. Angestellter ) , "1. Backlink wrong" ) ;
234	················pm.Save();
235	m = ( Mitarbeiter) pm. FindObject( m. NDOObjectId ) ;
236	svn = ( Sozialversicherungsnummer) pm. FindObject( svn. NDOObjectId ) ;
237	Assert. That( m != null, "1. Mitarbeiter not found" ) ;
238	Assert. That( svn != null, "1. SVN not found" ) ;
239	Assert. That( NDOObjectState. Persistent == svn. NDOObjectState, "2. Wrong state" ) ;
240	Assert. That( Object. ReferenceEquals( m, svn. Angestellter ) , "2. Backlink wrong" ) ;
241	············}
242	········}
243
244	········[Test]
245	········public void CompTestAddObjectAbort()
246	········{
247	using ( var pm = PmFactory. NewPersistenceManager( ) )
248	············{
249	················pm.MakePersistent( m );
250	················pm.Save();
251	················m.SVN = svn;
252	Assert. That( NDOObjectState. Created == svn. NDOObjectState, "1. Wrong state" ) ;
253	Assert. That( m. SVN != null, "1. SVN not found" ) ;
254	················pm.Abort();
255	Assert. That( NDOObjectState. Transient == svn. NDOObjectState, "2. Wrong state" ) ;
256	Assert. That( m. SVN == null, "1. SVN should be null" ) ;
257	Assert. That( svn. Angestellter == null, "1. Mitarbeiter should be null" ) ;
258	············}
259	········}
260
261
262	········[Test]
263	········public void CompTestReplaceChildSave()
264	········{
265	············using (var pm = PmFactory.NewPersistenceManager())
266	············{

267	················pm.MakePersistent( m );
268	················m.SVN = svn;
269	················pm.Save();
270	Assert. That( m. SVN != null, "1. SVN not found" ) ;
271	················Sozialversicherungsnummer svn2 = new Sozialversicherungsnummer();
272	················svn2.SVN = 0815;
273	················m.SVN = svn2;
274	Assert. That( NDOObjectState. Deleted == svn. NDOObjectState, "1. Wrong state" ) ;
275	Assert. That( NDOObjectState. Created == svn2. NDOObjectState, "2. Wrong state" ) ;
276	Assert. That( svn. Angestellter == null, "3. No relation to Mitarbeiter" ) ;
277	Assert. That( Object. ReferenceEquals( svn2. Angestellter, m ) , "4. Mitarbeiter should be same" ) ;
278	Assert. That( Object. ReferenceEquals( m. SVN, svn2 ) , "5. SVN should be same" ) ;
279	················pm.Save();
280	Assert. That( NDOObjectState. Transient == svn. NDOObjectState, "6. Wrong state" ) ;
281	Assert. That( NDOObjectState. Persistent == svn2. NDOObjectState, "7. Wrong state" ) ;
282	Assert. That( svn. Angestellter == null, "8. No relation to Mitarbeiter" ) ;
283	Assert. That( Object. ReferenceEquals( svn2. Angestellter, m ) , "9. Mitarbeiter should be same" ) ;
284	Assert. That( Object. ReferenceEquals( m. SVN, svn2 ) , "10. SVN should be same" ) ;
285	············}
286	········}
287
288	········[Test]
289	········public void CompTestReplaceChildAbort()
290	········{
291	using ( var pm = PmFactory. NewPersistenceManager( ) )
292	············{
293	················pm.MakePersistent( m );
294	················m.SVN = svn;
295	Assert. That( Object. ReferenceEquals( svn. Angestellter, m ) , "1. Mitarbeiter should be same" ) ;
296	················pm.Save();
297	Assert. That( m. SVN != null, "1. SVN not found" ) ;
298	················Sozialversicherungsnummer svn2 = new Sozialversicherungsnummer();
299	················svn2.SVN = 0815;
300	················m.SVN = svn2;
301	················pm.Abort();
302	Assert. That( NDOObjectState. Transient == svn2. NDOObjectState, "1. Wrong state" ) ;
303	Assert. That( NDOObjectState. Persistent == svn. NDOObjectState, "2. Wrong state" ) ;
304	Assert. That( svn2. Angestellter == null, "3. No relation to Mitarbeiter" ) ;
305	Assert. That( Object. ReferenceEquals( svn. Angestellter, m ) , "4. Mitarbeiter should be same" ) ;
306	Assert. That( Object. ReferenceEquals( m. SVN, svn ) , "5. SVN should be same" ) ;
307	············}
308	········}
309
310	········[Test]
311	········public void CompTestReplaceParent()
312	········{
313	using ( var pm = PmFactory. NewPersistenceManager( ) )
314	············{
315	················pm.MakePersistent( m );
316	················m.SVN = svn;
317	················pm.Save();
318	Assert. That( m. SVN != null, "1. SVN not found" ) ;
319	················Mitarbeiter m2 = CreateMitarbeiter( "Andre", "Agassi" );
320	················var thrown = false;
321	················try
322	················{
323	····················svn.Angestellter = m2;
324	················}
325	················catch (NDOException)
326	················{
327	····················thrown = true;
328	················}
329	················Assert.That( true == thrown );
330	············}

331	········}
332
333
334	········[Test]
335	········public void CompTestRemoveObjectSave()
336	········{
337	using ( var pm = PmFactory. NewPersistenceManager( ) )
338	············{
339	················pm.MakePersistent( m );
340	················m.SVN = svn;
341	················pm.Save();
342	················ObjectId moid = m.NDOObjectId;
343	Assert. That( m. SVN != null, "1. SVN not found" ) ;
344	················m.SVN = null;
345	Assert. That( NDOObjectState. Deleted == svn. NDOObjectState, "1. Wrong state" ) ;
346	Assert. That( m. SVN == null, "1. SVN should be null" ) ;
347	Assert. That( svn. Angestellter == null, "1. Mitarbeiter should be null" ) ;
348	················pm.Save();
349	Assert. That( m. SVN == null, "2. SVN should be null" ) ;
350	Assert. That( NDOObjectState. Transient == svn. NDOObjectState, "2. Wrong state" ) ;
351	················moid = m.NDOObjectId;
352	················pm.UnloadCache();
353	m = ( Mitarbeiter) pm. FindObject( moid ) ;
354	Assert. That( m != null, "3. Mitarbeiter not found" ) ;
355	Assert. That( m. SVN == null, "3. SVN should be null" ) ;
356	············}
357	········}
358
359	········[Test]
360	········public void CompTestRemoveObjectAbort()
361	········{
362	using ( var pm = PmFactory. NewPersistenceManager( ) )
363	············{
364	················pm.MakePersistent( m );
365	················m.SVN = svn;
366	················pm.Save();
367	Assert. That( m. SVN != null, "1. SVN not found" ) ;
368	················m.SVN = null;
369	Assert. That( NDOObjectState. Deleted == svn. NDOObjectState, "1. Wrong state" ) ;
370	Assert. That( m. SVN == null, "2. SVN should be null" ) ;
371	················pm.Abort();
372	Assert. That( m. SVN != null, "2. SVN not found" ) ;
373	Assert. That( NDOObjectState. Persistent == svn. NDOObjectState, "2. Wrong state" ) ;
374	Assert. That( Object. ReferenceEquals( m, svn. Angestellter ) , "2. Backlink wrong" ) ;
375	············}
376	········}
377
378	········[Test]
379	········public void CompTestRemoveParentSave()
380	········{
381	············using (var pm = PmFactory.NewPersistenceManager())
382	············{

383	················pm.MakePersistent( m );
384	················m.SVN = svn;
385	················pm.Save();
386
387	················Assert.That( svn.Angestellter != null, "1. Mitarbeiter not found" );
388	················var thrown = false;
389	················try
390	················{
391	····················svn.Angestellter = null;··// Cannot manipulate composition through child object.
392	················}
393	················catch (NDOException)
394	················{
395	····················thrown = true;
396	················}
397	Assert. That( true == thrown ) ;
398	············}
399	········}
400
401
402	········[Test]
403	········public void CompTestDeleteSave()
404	········{
405	using ( var pm = PmFactory. NewPersistenceManager( ) )
406	············{
407	················pm.MakePersistent( m );
408	················pm.Save();
409	················m.SVN = svn;
410	················pm.Save();
411	················pm.Delete( m );
412	Assert. That( NDOObjectState. Deleted == m. NDOObjectState, "1. Wrong state" ) ;
413	Assert. That( NDOObjectState. Deleted == svn. NDOObjectState, "2. Wrong state" ) ;
414	················pm.Save();
415
416	Assert. That( NDOObjectState. Transient == m. NDOObjectState, "1. Wrong state" ) ;
417	················Assert.That( NDOObjectState.Transient == svn.NDOObjectState, "2. Wrong state" );
418	················// Objects should retain relations in memory
419	Assert. That( m. SVN != null, "3. SVN shouldn't be null" ) ;
420	Assert. That( svn. Angestellter == null, "3. Mitarbeiter should be null" ) ;
421	············}
422	········}
423
424	········[Test]
425	········public void CompTestDeleteChildSave()
426	········{
427	using ( var pm = PmFactory. NewPersistenceManager( ) )
428	············{
429	················bool thrown = false;
430	················pm.MakePersistent( m );
431	················pm.Save();
432	················m.SVN = svn;
433	················pm.Save();
434	················try
435	················{
436	····················pm.Delete( svn ); // Should throw an Exception
437	················}
438	················catch (NDOException e)
439	················{
440	····················thrown = true;
441	················}
442	················Assert.That( thrown, "Exception mösste ausgelöst worden sein" );
443	············}
444	········}
445
446
447	········[Test]
448	········public void CompTestDeleteAbort()
449	········{
450	using ( var pm = PmFactory. NewPersistenceManager( ) )
451	············{
452	················pm.MakePersistent( m );
453	················pm.Save();
454	················m.SVN = svn;
455	················pm.Save();
456	················pm.Delete( m );
457	Assert. That( NDOObjectState. Deleted == m. NDOObjectState, "1. Wrong state" ) ;
458	Assert. That( NDOObjectState. Deleted == svn. NDOObjectState, "2. Wrong state" ) ;
459	················pm.Abort();
460	Assert. That( NDOObjectState. Persistent == m. NDOObjectState, "1. Wrong state" ) ;
461	Assert. That( NDOObjectState. Persistent == svn. NDOObjectState, "2. Wrong state" ) ;
462	Assert. That( m. SVN != null, "2. SVN not found" ) ;
463	Assert. That( Object. ReferenceEquals( m, svn. Angestellter ) , "2. Backlink wrong" ) ;
464	············}
465	········}
466
467	········[Test]
468	········public void CompTestCreateDelete()
469	········{
470	using ( var pm = PmFactory. NewPersistenceManager( ) )
471	············{
472	················pm.MakePersistent( m );
473	················m.SVN = svn;
474	················pm.Delete( m );
475	Assert. That( NDOObjectState. Transient == m. NDOObjectState, "1. Wrong state" ) ;
476	Assert. That( NDOObjectState. Transient == svn. NDOObjectState, "2. Wrong state" ) ;
477	················// Objects should retain relations in memory
478	Assert. That( m. SVN != null, "3. SVN shouldn't be null" ) ;
479	Assert. That( svn. Angestellter == null, "3. Mitarbeiter should be null" ) ;
480	············}
481	········}
482
483	········[Test]
484	········public void CompTestAddRemoveSave()
485	········{
486	using ( var pm = PmFactory. NewPersistenceManager( ) )
487	············{
488	················pm.MakePersistent( m );
489	················pm.Save();
490	················m.SVN = svn;
491	················m.SVN = null;
492	Assert. That( NDOObjectState. Transient == svn. NDOObjectState, "1. Wrong state" ) ;
493	Assert. That( m. SVN == null, "1. SVN should be null" ) ;
494	Assert. That( svn. Angestellter == null, "1. Mitarbeiter should be null" ) ;
495	················pm.Save();
496	Assert. That( NDOObjectState. Transient == svn. NDOObjectState, "2. Wrong state" ) ;
497	Assert. That( m. SVN == null, "2. SVN should be null" ) ;
498	Assert. That( svn. Angestellter == null, "3. Mitarbeiter should be null" ) ;
499	············}
500	········}
501
502	········[Test]
503	········public void CompTestAddRemoveAbort()
504	········{
505	using ( var pm = PmFactory. NewPersistenceManager( ) )
506	············{
507	················pm.MakePersistent( m );
508	················pm.Save();
509	················m.SVN = svn;
510	················m.SVN = null;
511	Assert. That( NDOObjectState. Transient == svn. NDOObjectState, "1. Wrong state" ) ;
512	················pm.Abort();
513	············}
514
515	············Assert.That(NDOObjectState.Transient ==··svn.NDOObjectState, "2. Wrong state" );
516	············Assert.That(m.SVN == null, "2. SVN should be null" );
517	············Assert.That(svn.Angestellter == null, "3. Mitarbeiter should be null" );
518	········}
519
520
521
522	········[Test]
523	········public void CompTestHollow()
524	········{
525	ObjectId oid;
526	············using (var pm = PmFactory.NewPersistenceManager())
527	············{
528	················m.SVN = svn;
529	················pm.MakePersistent( m );
530	················pm.Save();
531	················pm.MakeHollow( m ); // setzt m.svn auf null
532
533	Assert. That( NDOObjectState. Hollow == m. NDOObjectState, "1: Mitarbeiter should be hollow" ) ;
534	Assert. That( NDOObjectState. Persistent == svn. NDOObjectState, "1: SVN should be persistent" ) ;
535
536	················svn = m.SVN; // ruft LoadData för m auf. m.svm liegt auf dem Cache und ist Persistent
537	Assert. That( NDOObjectState. Persistent == m. NDOObjectState, "1: Mitarbeiter should be persistent" ) ;
538	Assert. That( NDOObjectState. Persistent == svn. NDOObjectState, "2: SVN should be persistent" ) ;
539	oid = m. NDOObjectId;
540	}
541
542	using ( var pm = PmFactory. NewPersistenceManager( ) )
543	{
544	m = ( Mitarbeiter) pm. FindObject( oid ) ;
545	················Assert.That( m != null, "Mitarbeiter not found" );
546	················Assert.That( NDOObjectState.Hollow == m.NDOObjectState, "2: Mitarbeiter should be hollow" );
547	················svn = m.SVN;
548	Assert. That( NDOObjectState. Persistent == m. NDOObjectState, "2: Mitarbeiter should be persistent" ) ;
549	Assert. That( svn != null, "SVN not found" ) ;
550	Assert. That( NDOObjectState. Hollow == svn. NDOObjectState, "1: SVN should be hollow" ) ;
551	Assert. That( Object. ReferenceEquals( m, svn. Angestellter ) , "2. Backlink wrong" ) ;
552	············}
553	········}
554
555
556	········[Test]
557	········public void CompTestMakeAllHollow()
558	········{
559	using ( var pm = PmFactory. NewPersistenceManager( ) )
560	············{
561	················m.SVN = svn;
562	················pm.MakePersistent( m );
563	················pm.Save();
564	················pm.MakeAllHollow();
565	Assert. That( NDOObjectState. Hollow == m. NDOObjectState, "1: Mitarbeiter should be hollow" ) ;
566	Assert. That( NDOObjectState. Hollow == svn. NDOObjectState, "1: SVN should be hollow" ) ;
567	Assert. That( Object. ReferenceEquals( m, svn. Angestellter ) , "2. Backlink wrong" ) ;
568	············}
569	········}
570
571	········[Test]
572	········public void CompTestMakeAllHollowUnsaved()
573	········{
574	using ( var pm = PmFactory. NewPersistenceManager( ) )
575	············{
576	················m.SVN = svn;
577	················pm.MakePersistent( m );
578	················pm.MakeAllHollow();··// before save, objects cannot be made hollow. => in locked objects
579	Assert. That( NDOObjectState. Created == m. NDOObjectState, "1: Mitarbeiter should be created" ) ;
580	Assert. That( NDOObjectState. Created == svn. NDOObjectState, "1: SVN should be created" ) ;
581	············}
582	········}
583
584	········[Test]
585	········public void CompTestLockRelations()
586	········{
587	using ( var pm = PmFactory. NewPersistenceManager( ) )
588	············{
589	················m.SVN = svn;
590	················pm.MakePersistent( m );
591	················m.Adresse = new Adresse();
592	················m.Adresse.Lkz = "Bla";
593	················pm.Save();
594	················pm.Delete( m );
595	················pm.Save();
596	Assert. That( NDOObjectState. Transient == m. NDOObjectState, "1: mitarbeiter should be transient" ) ;
597	Assert. That( NDOObjectState. Transient == m. SVN. NDOObjectState, "1: SVN should be transient" ) ;
598	Assert. That( NDOObjectState. Transient == m. Adresse. NDOObjectState, "1: Adresse should be transient" ) ;
599	············}
600	········}
601
602	········[Test]
603	········public void CompTestExtentRelatedObjects()
604	········{
605	using ( var pm = PmFactory. NewPersistenceManager( ) )
606	············{
607	················m.SVN = svn;
608	················pm.MakePersistent( m );
609	················pm.Save();
610	················IList liste = pm.GetClassExtent( typeof( Mitarbeiter ) );
611	m = ( Mitarbeiter) liste[0];
612	Assert. That( NDOObjectState. Persistent == m. NDOObjectState, "1: Mitarbeiter should be persistent" ) ;
613	Assert. That( m. SVN != null, "2. Relation is missing" ) ;
614	Assert. That( NDOObjectState. Persistent == m. SVN. NDOObjectState, "2. : SVN should be hollow" ) ;
615	Assert. That( Object. ReferenceEquals( m, svn. Angestellter ) , "2. Backlink wrong" ) ;
616
617	················pm.UnloadCache();
618	················liste = pm.GetClassExtent( typeof( Mitarbeiter ) );
619	m = ( Mitarbeiter) liste[0];
620	Assert. That( NDOObjectState. Hollow == m. NDOObjectState, "5: Mitarbeiter should be hollow" ) ;
621	Assert. That( m. SVN != null, "6. Relation is missing" ) ;
622	Assert. That( NDOObjectState. Hollow == m. SVN. NDOObjectState, "8. : SVN should be hollow" ) ;
623	················Assert.That( m != svn.Angestellter, "8a. Should be different objects" );
624	Assert. That( Object. ReferenceEquals( m, m. SVN. Angestellter ) , "8b. Mitarbeiter should match" ) ;
625
626	················pm.UnloadCache();
627	················liste = pm.GetClassExtent( typeof( Mitarbeiter ), false );
628	m = ( Mitarbeiter) liste[0];
629	Assert. That( NDOObjectState. Persistent == m. NDOObjectState, "9: Mitarbeiter should be persistent" ) ;
630	Assert. That( m. SVN != null, "10. Relation is missing" ) ;
631	Assert. That( NDOObjectState. Hollow == m. SVN. NDOObjectState, "12. : SVN should be hollow" ) ;
632	················Assert.That( m != svn.Angestellter, "12a. Should be different objects" );
633	Assert. That( Object. ReferenceEquals( m, m. SVN. Angestellter ) , "12b. Mitarbeiter should match" ) ;
634	············}
635	········}
636
637	········#endregion
638
639	········#region Aggregation Tests
640
641	········[Test]
642	········public void AggrTestCreateObjectsTransient()
643	········{
644	using ( var pm = PmFactory. NewPersistenceManager( ) )
645	············{
646	················e.Schlüssel = z0;
647	················var thrown = false;
648	················try
649	················{
650	····················pm.MakePersistent( e );
651	················}
652	················catch (NDOException)
653	················{
654	····················thrown = true;
655	················}
656	Assert. That( true == thrown ) ;
657	············}
658	········}
659
660	········[Test]
661	········public void AggrTestCreateObjectsTransient2()
662	········{
663	············using (var pm = PmFactory.NewPersistenceManager())
664	············{

665	················pm.MakePersistent( e );
666	················var thrown = false;
667	················try
668	················{
669	····················e.Schlüssel = z0;
670	················}
671	················catch (NDOException)
672	················{
673	····················thrown = true;
674	················}
675	Assert. That( true == thrown ) ;
676	············}
677	········}
678
679	········[Test]
680	········public void AggrTestCreateObjectsSave()
681	········{
682	············using (var pm = PmFactory.NewPersistenceManager())
683	············{

684	················pm.MakePersistent( z0 );
685	················e.Schlüssel = z0;
686	················pm.MakePersistent( e );
687	················pm.Save();
688	················Assert.That( !e.NDOObjectId.Equals( e.Schlüssel.NDOObjectId ), "Ids should be different" );
689	e = ( Email) pm. FindObject( e. NDOObjectId ) ;
690	z0 = ( Zertifikat) pm. FindObject( e. Schlüssel. NDOObjectId ) ;
691	Assert. That( e != null, "1. Email not found" ) ;
692	Assert. That( z0 != null, "1. Zertifikat not found" ) ;
693	················ObjectId moid = e.NDOObjectId;
694	················ObjectId soid = z0.NDOObjectId;
695	················e = null;
696	················z0 = null;
697
698	················pm.UnloadCache();
699	e = ( Email) pm. FindObject( moid ) ;
700	················var z1 = pm.Objects<Zertifikat>().Where(z=>z.Oid() == soid.Id.Value).SingleOrDefault();
701	················Assert.That( z1 != null );
702	················Zertifikat z2 = e.Schlüssel;
703	Assert. That( Object. ReferenceEquals( z1, z2 ) ) ;
704	z0 = ( Zertifikat) pm. FindObject( soid ) ;
705	Assert. That( e != null, "2. Email not found" ) ;
706	Assert. That( z0 != null, "2. Zertifikat not found" ) ;
707	Assert. That( Object. ReferenceEquals( z0, z2 ) , "Zertifikat should match" ) ;
708	Assert. That( Object. ReferenceEquals( e, z0. Adresse ) , "Email should match" ) ;
709	············}
710	········}
711
712	········[Test]
713	········public void AggrTestCreateObjectsWithTransaction()
714	········{
715	using ( var pm = PmFactory. NewPersistenceManager( ) )
716	············{
717	················var tm = pm.TransactionMode;
718	················try
719	················{
720	····················// See Issue #1145
721	····················// The test would fail, if we didn't alter the update rank
722	····················// according to the actual situation, that e has a valid database id.
723	····················// The test would fail, because the update rank would cause e to be saved first
724	····················// at the 2nd Save() call.
725	····················pm.TransactionMode = TransactionMode.Optimistic;
726	····················pm.MakePersistent( e );
727	····················pm.Save( true );
728	····················pm.MakePersistent( z0 );
729	····················e.Schlüssel = z0;
730	····················pm.Save();
731	····················pm.UnloadCache();
732	····················pm.TransactionMode = TransactionMode.None;
733	····················var email = pm.Objects<Email>().Single();
734	Assert. That( email. Schlüssel != null ) ;
735	Assert. That( 42 == email. Schlüssel. Key ) ;
736	····················pm.UnloadCache();
737	····················var zertifikat = pm.Objects<Zertifikat>().Single();
738	Assert. That( zertifikat. Adresse != null ) ;
739	················}
740	················finally
741	················{
742	····················pm.TransactionMode = tm;
743	················}
744	············}
745	········}
746
747
748	········[Test]
749	········public void AggrSimpleObjectSave()
750	········{
751	using ( var pm = PmFactory. NewPersistenceManager( ) )
752	············{
753	················pm.MakePersistent( z0 );
754	················pm.Save();
755	············}
756	········}
757
758	········[Test]
759	········public void AggrChildAddFail()
760	········{
761	using ( var pm = PmFactory. NewPersistenceManager( ) )
762	············{
763	················pm.MakePersistent( z0 );
764	················pm.MakePersistent( e );
765	················z0.Adresse = e;
766	············}
767	········}
768
769	········[Test]
770	········public void AggrChildAddFail2()
771	········{
772	using ( var pm = PmFactory. NewPersistenceManager( ) )
773	············{
774	················pm.MakePersistent( e );
775	················pm.MakePersistent( z0 );
776	················pm.Save();
777	················z0.Adresse = e;
778	············}
779	········}
780
781	········[Test]
782	········public void AggrChildAdd3()
783	········{
784	using ( var pm = PmFactory. NewPersistenceManager( ) )
785	············{
786	················pm.MakePersistent( e );
787	················pm.MakePersistent( z0 );
788	················pm.Save();
789	················e.Schlüssel = z0;
790	················z0.Adresse = e;
791	············}
792	········}
793
794	········[Test]
795	········public void AggrChildAdd4()
796	········{
797	using ( var pm = PmFactory. NewPersistenceManager( ) )
798	············{
799	················pm.MakePersistent( z0 );
800	················pm.MakePersistent( e );
801	················pm.Save();
802	················e.Schlüssel = z0;
803	················z0.Adresse = null;
804	············}
805	········}
806
807	········[Test]
808	········public void AggrTestAddObjectSave()
809	········{
810	using ( var pm = PmFactory. NewPersistenceManager( ) )
811	············{
812	················pm.MakePersistent( z0 );
813	················pm.MakePersistent( e );
814	················pm.Save();
815	················e.Schlüssel = z0;
816	Assert. That( NDOObjectState. PersistentDirty == z0. NDOObjectState, "1. Wrong state" ) ;
817	Assert. That( Object. ReferenceEquals( e, z0. Adresse ) , "1. Backlink wrong" ) ;
818	················pm.Save();
819	e = ( Email) pm. FindObject( e. NDOObjectId ) ;
820	z0 = ( Zertifikat) pm. FindObject( z0. NDOObjectId ) ;
821	Assert. That( e != null, "1. Email not found" ) ;
822	Assert. That( z0 != null, "1. Zertifikat not found" ) ;
823	Assert. That( NDOObjectState. Persistent == z0. NDOObjectState, "2. Wrong state" ) ;
824	Assert. That( Object. ReferenceEquals( e, z0. Adresse ) , "2. Backlink wrong" ) ;
825	············}
826	········}
827
828	········[Test]
829	········public void AggrTestAddObjectAbort()
830	········{
831	using ( var pm = PmFactory. NewPersistenceManager( ) )
832	············{
833	················pm.MakePersistent( z0 );
834	················pm.MakePersistent( e );
835	················pm.Save();
836	················e.Schlüssel = z0;
837	Assert. That( NDOObjectState. PersistentDirty == z0. NDOObjectState, "1. Wrong state" ) ;
838	Assert. That( e. Schlüssel != null, "1. Zertifikat not found" ) ;
839	················pm.Abort();
840	Assert. That( NDOObjectState. Persistent == z0. NDOObjectState, "2. Wrong state" ) ;
841	Assert. That( e. Schlüssel == null, "1. Zertifikat should be null" ) ;
842	Assert. That( z0. Adresse == null, "1. Email should be null" ) ;
843	············}
844	········}
845
846
847	········[Test]
848	········public void AggrTestReplaceChildSave()
849	········{
850	using ( var pm = PmFactory. NewPersistenceManager( ) )
851	············{
852	················pm.MakePersistent( z0 );
853	················pm.MakePersistent( e );
854	················e.Schlüssel = z0;
855	················pm.Save();
856	Assert. That( e. Schlüssel != null, "1. Zertifikat not found" ) ;
857	················Zertifikat z2 = new Zertifikat();
858	················z2.Key = 0815;
859	················pm.MakePersistent( z2 );
860	················e.Schlüssel = z2;
861	Assert. That( NDOObjectState. PersistentDirty == z0. NDOObjectState, "1. Wrong state" ) ;
862	Assert. That( NDOObjectState. Created == z2. NDOObjectState, "2. Wrong state" ) ;
863	Assert. That( z0. Adresse == null, "3. No relation to Email" ) ;
864	Assert. That( Object. ReferenceEquals( z2. Adresse, e ) , "4. Email should be same" ) ;
865	Assert. That( Object. ReferenceEquals( e. Schlüssel, z2 ) , "5. Zertifikat should be same" ) ;
866	················pm.Save();
867	Assert. That( NDOObjectState. Persistent == z0. NDOObjectState, "6. Wrong state" ) ;
868	Assert. That( NDOObjectState. Persistent == z2. NDOObjectState, "7. Wrong state" ) ;
869	Assert. That( z0. Adresse == null, "8. No relation to Email" ) ;
870	Assert. That( Object. ReferenceEquals( z2. Adresse, e ) , "9. Email should be same" ) ;
871	Assert. That( Object. ReferenceEquals( e. Schlüssel, z2 ) , "10. Zertifikat should be same" ) ;
872	············}
873	········}
874
875	········[Test]
876	········public void AggrTestReplaceChildAbort()
877	········{
878	using ( var pm = PmFactory. NewPersistenceManager( ) )
879	············{
880	················pm.MakePersistent( z0 );
881	················pm.MakePersistent( e );
882	················e.Schlüssel = z0;
883	················pm.Save();
884	Assert. That( e. Schlüssel != null, "1. Zertifikat not found" ) ;
885	················Zertifikat z2 = new Zertifikat();
886	················z2.Key = 0815;
887	················pm.MakePersistent( z2 );
888	················e.Schlüssel = z2;
889	················pm.Abort();
890	Assert. That( NDOObjectState. Transient == z2. NDOObjectState, "1. Wrong state" ) ;
891	Assert. That( NDOObjectState. Persistent == z0. NDOObjectState, "2. Wrong state" ) ;
892	Assert. That( z2. Adresse == null, "3. No relation to Email" ) ;
893	Assert. That( Object. ReferenceEquals( z0. Adresse, e ) , "4. Email should be same" ) ;
894	Assert. That( Object. ReferenceEquals( e. Schlüssel, z0 ) , "5. Zertifikat should be same" ) ;
895	············}
896	········}
897
898	········[Test]
899	········public void AggrTestReplaceParentSave()
900	········{
901	using ( var pm = PmFactory. NewPersistenceManager( ) )
902	············{
903	················pm.MakePersistent( z0 );
904	················pm.MakePersistent( e );
905	················e.Schlüssel = z0;
906	················pm.Save();
907	Assert. That( e. Schlüssel != null, "1. Zertifikat not found" ) ;
908	················Email m2 = new Email( "db@cortex-brainware.de" );
909	················pm.MakePersistent( m2 );
910	················z0.Adresse = m2;
911	············}
912	········}
913
914
915	········[Test]
916	········public void AggrTestRemoveObjectSave()
917	········{
918	using ( var pm = PmFactory. NewPersistenceManager( ) )
919	············{
920	················pm.MakePersistent( z0 );
921	················pm.MakePersistent( e );
922	················e.Schlüssel = z0;
923	················pm.Save();
924	Assert. That( e. Schlüssel != null, "1. Zertifikat not found" ) ;
925	················ObjectId aoid = z0.NDOObjectId;
926	················e.Schlüssel = null;
927	Assert. That( NDOObjectState. PersistentDirty == z0. NDOObjectState, "1. Wrong state" ) ;
928	Assert. That( e. Schlüssel == null, "1. Zertifikat should be null" ) ;
929	Assert. That( z0. Adresse == null, "1. Email should be null" ) ;
930	················pm.Save();
931	Assert. That( e. Schlüssel == null, "2. Zertifikat should be null" ) ;
932	Assert. That( NDOObjectState. Persistent == z0. NDOObjectState, "2. Wrong state" ) ;
933	················ObjectId moid = e.NDOObjectId;
934	················Assert.That( aoid.IsValid(), "Still valid Zertifikat" );
935	················pm.UnloadCache();
936	e = ( Email) pm. FindObject( moid ) ;
937	Assert. That( e != null, "3. Email not found" ) ;
938	Assert. That( e. Schlüssel == null, "3. Zertifikat should be null" ) ;
939	············}
940	········}
941
942	········[Test]
943	········public void AggrTestRemoveObjectAbort()
944	········{
945	using ( var pm = PmFactory. NewPersistenceManager( ) )
946	············{
947	················pm.MakePersistent( z0 );
948	················pm.MakePersistent( e );
949	················e.Schlüssel = z0;
950	················pm.Save();
951	Assert. That( e. Schlüssel != null, "1. Zertifikat not found" ) ;
952	················e.Schlüssel = null;
953	Assert. That( NDOObjectState. PersistentDirty == z0. NDOObjectState, "1. Wrong state" ) ;
954	Assert. That( e. Schlüssel == null, "2. Zertifikat should be null" ) ;
955	················pm.Abort();
956	Assert. That( e. Schlüssel != null, "2. Zertifikat not found" ) ;
957	Assert. That( NDOObjectState. Persistent == z0. NDOObjectState, "2. Wrong state" ) ;
958	Assert. That( Object. ReferenceEquals( e, z0. Adresse ) , "2. Backlink wrong" ) ;
959	············}
960	········}
961
962	········[Test]
963	········public void AggrTestRemoveParentSave()
964	········{
965	using ( var pm = PmFactory. NewPersistenceManager( ) )
966	············{
967	················pm.MakePersistent( z0 );
968	················pm.MakePersistent( e );
969	················e.Schlüssel = z0;
970	················pm.Save();
971	Assert. That( z0. Adresse != null, "1. Email not found" ) ;
972	················ObjectId aoid = z0.NDOObjectId;
973	················z0.Adresse = null;
974	Assert. That( NDOObjectState. PersistentDirty == z0. NDOObjectState, "1. Wrong state" ) ;
975	Assert. That( e. Schlüssel == null, "1. Zertifikat should be null" ) ;
976	Assert. That( z0. Adresse == null, "1. Email should be null" ) ;
977	················pm.Save();
978	Assert. That( e. Schlüssel == null, "2. Zertifikat should be null" ) ;
979	Assert. That( NDOObjectState. Persistent == z0. NDOObjectState, "2. Wrong state" ) ;
980	················ObjectId moid = e.NDOObjectId;
981	················Assert.That( aoid.IsValid(), "Zertifikat still valid" );
982	················pm.UnloadCache();
983	e = ( Email) pm. FindObject( moid ) ;
984	Assert. That( e != null, "3. Email not found" ) ;
985	Assert. That( e. Schlüssel == null, "3. Zertifikat should be null" ) ;
986	············}
987	········}
988
989	········[Test]
990	········public void AggrTestRemoveParentAbort()
991	········{
992	using ( var pm = PmFactory. NewPersistenceManager( ) )
993	············{
994	················pm.MakePersistent( z0 );
995	················pm.MakePersistent( e );
996	················e.Schlüssel = z0;
997	················pm.Save();
998	Assert. That( e. Schlüssel != null, "1. Zertifikat not found" ) ;
999	················z0.Adresse = null;
1000	Assert. That( NDOObjectState. PersistentDirty == z0. NDOObjectState, "1. Wrong state" ) ;
1001	Assert. That( e. Schlüssel == null, "2. Zertifikat should be null" ) ;
1002	················pm.Abort();
1003	Assert. That( e. Schlüssel != null, "2. Zertifikat not found" ) ;
1004	Assert. That( NDOObjectState. Persistent == z0. NDOObjectState, "2. Wrong state" ) ;
1005	Assert. That( Object. ReferenceEquals( e, z0. Adresse ) , "2. Backlink wrong" ) ;
1006	············}











1007	········}

1008









1009
1010	········[Test]
1011	········public void AggrTestCreateDeleteAllowed()
1012	········{
1013	using ( var pm = PmFactory. NewPersistenceManager( ) )
1014	············{
1015	················pm.MakePersistent( z0 );
1016	················pm.MakePersistent( e );
1017	················e.Schlüssel = z0;
1018	················e.Schlüssel = null;
1019	················pm.Delete( e );
1020	Assert. That( NDOObjectState. Created == z0. NDOObjectState, "1. Wrong state" ) ;
1021	Assert. That( NDOObjectState. Transient == e. NDOObjectState, "2. Wrong state" ) ;
1022	Assert. That( e. Schlüssel == null, "3. Zertifikat should be null" ) ;
1023	Assert. That( z0. Adresse == null, "4. Email should be null" ) ;
1024	············}
1025	········}
1026
1027
1028	········[Test]
1029	········public void AggrTestAddRemoveSave()
1030	········{
1031	using ( var pm = PmFactory. NewPersistenceManager( ) )
1032	············{
1033	················pm.MakePersistent( e );
1034	················pm.MakePersistent( z0 );
1035	················pm.Save();
1036	················e.Schlüssel = z0;
1037	················e.Schlüssel = null;
1038	Assert. That( NDOObjectState. PersistentDirty == z0. NDOObjectState, "1. Wrong state" ) ;
1039	Assert. That( e. Schlüssel == null, "1. Zertifikat should be null" ) ;
1040	Assert. That( z0. Adresse == null, "1. Email should be null" ) ;
1041	················pm.Save();
1042	Assert. That( NDOObjectState. Persistent == z0. NDOObjectState, "2. Wrong state" ) ;
1043	Assert. That( e. Schlüssel == null, "2. Zertifikat should be null" ) ;
1044	Assert. That( z0. Adresse == null, "3. Email should be null" ) ;
1045	············}
1046	········}
1047
1048	········[Test]
1049	········public void AggrTestAddRemoveAbort()
1050	········{
1051	using ( var pm = PmFactory. NewPersistenceManager( ) )
1052	············{
1053	················pm.MakePersistent( e );
1054	················pm.MakePersistent( z0 );
1055	················pm.Save();
1056	················e.Schlüssel = z0;
1057	················e.Schlüssel = null;
1058	Assert. That( NDOObjectState. PersistentDirty == z0. NDOObjectState, "1. Wrong state" ) ;
1059	················pm.Abort();
1060	Assert. That( NDOObjectState. Persistent == z0. NDOObjectState, "2. Wrong state" ) ;
1061	Assert. That( e. Schlüssel == null, "2. Zertifikat should be null" ) ;
1062	Assert. That( z0. Adresse == null, "3. Email should be null" ) ;
1063	············}
1064	········}
1065
1066

1067	········[Test]
1068	········public void AggrTestHollow()
1069	········{
1070	ObjectId oid;
1071	············using (var pm = PmFactory.NewPersistenceManager())
1072	············{
1073	················pm.MakePersistent( z0 );
1074	················e.Schlüssel = z0;
1075	················pm.MakePersistent( e );
1076	················pm.Save();
1077	················pm.MakeHollow( e ); // setzt e.z auf null
1078
1079	Assert. That( NDOObjectState. Hollow == e. NDOObjectState, "1: Email should be hollow" ) ;
1080	Assert. That( NDOObjectState. Persistent == z0. NDOObjectState, "1: Zertifikat should be persistent" ) ;
1081
1082	················z0 = e.Schlüssel; // ruft LoadData för e auf. e.svm liegt auf dem Cache und ist Persistent
1083	Assert. That( NDOObjectState. Persistent == e. NDOObjectState, "1: Email should be persistent" ) ;
1084	Assert. That( NDOObjectState. Persistent == z0. NDOObjectState, "2: Zertifikat should be persistent" ) ;
1085	oid = e. NDOObjectId;
1086	}
1087	using ( var pm = PmFactory. NewPersistenceManager( ) )
1088	{
1089	e = ( Email) pm. FindObject( oid ) ;
1090	Assert. That( e != null, "Email not found" ) ;
1091	················Assert.That( NDOObjectState.Hollow == e.NDOObjectState, "2: Email should be hollow" );
1092	················z0 = e.Schlüssel;
1093	Assert. That( NDOObjectState. Persistent == e. NDOObjectState, "2: Email should be persistent" ) ;
1094	Assert. That( z0 != null, "Zertifikat not found" ) ;
1095	Assert. That( NDOObjectState. Hollow == z0. NDOObjectState, "1: Zertifikat should be hollow" ) ;
1096	Assert. That( Object. ReferenceEquals( e, z0. Adresse ) , "2. Backlink wrong" ) ;
1097	············}
1098	········}
1099
1100
1101	········[Test]
1102	········public void AggrTestMakeAllHollowDelete()
1103	········{
1104	using ( var pm = PmFactory. NewPersistenceManager( ) )
1105	············{
1106	················pm.MakePersistent( z0 );
1107	················e.Schlüssel = z0;
1108	················pm.MakePersistent( e );
1109	················pm.Save();
1110	················pm.MakeAllHollow();
1111	Assert. That( NDOObjectState. Hollow == e. NDOObjectState, "1: Email should be hollow" ) ;
1112	Assert. That( NDOObjectState. Hollow == z0. NDOObjectState, "1: Zertifikat should be hollow" ) ;
1113	················Zertifikat zz = e.Schlüssel;··// Das lödt das Objekt, deshalb geht es hier!
1114	················e.Schlüssel = null;
1115	Assert. That( NDOObjectState. PersistentDirty == e. NDOObjectState, "2: Email should be persistent dirty" ) ;
1116	Assert. That( NDOObjectState. PersistentDirty == z0. NDOObjectState, "2: Zertifikat should be persistent dirty" ) ;
1117	Assert. That( e. Schlüssel == null, "3. Email should have no Zertifikat" ) ;
1118	Assert. That( z0. Adresse == null, "3. Zertifikat should have no Email" ) ;
1119	················pm.Delete( e );
1120	············}
1121	········}
1122
1123	········[Test]
1124	········public void AggrTestMakeAllHollow()
1125	········{
1126	using ( var pm = PmFactory. NewPersistenceManager( ) )
1127	············{
1128	················pm.MakePersistent( z0 );
1129	················e.Schlüssel = z0;
1130	················pm.MakePersistent( e );
1131	················pm.Save();
1132	················pm.MakeAllHollow();
1133	Assert. That( NDOObjectState. Hollow == e. NDOObjectState, "1: Email should be hollow" ) ;
1134	Assert. That( NDOObjectState. Hollow == z0. NDOObjectState, "1: Zertifikat should be hollow" ) ;
1135	Assert. That( Object. ReferenceEquals( e, z0. Adresse ) , "2. Backlink wrong" ) ;
1136	············}
1137	········}
1138
1139	········[Test]
1140	········public void AggrTestMakeAllHollowUnsaved()
1141	········{
1142	using ( var pm = PmFactory. NewPersistenceManager( ) )
1143	············{
1144	················pm.MakePersistent( z0 );
1145	················e.Schlüssel = z0;
1146	················pm.MakePersistent( e );
1147	················pm.MakeAllHollow();··// before save, objects cannot be made hollow. => in locked objects
1148	Assert. That( NDOObjectState. Created == e. NDOObjectState, "1: Email should be created" ) ;
1149	Assert. That( NDOObjectState. Created == z0. NDOObjectState, "1: Zertifikat should be created" ) ;
1150	············}
1151	········}
1152
1153
1154	········[Test]
1155	········public void AggrTestExtentRelatedObjects()
1156	········{
1157	using ( var pm = PmFactory. NewPersistenceManager( ) )
1158	············{
1159	················pm.MakePersistent( z0 );
1160	················e.Schlüssel = z0;
1161	················pm.MakePersistent( e );
1162	················pm.Save();
1163	················IList liste = pm.GetClassExtent( typeof( Email ) );
1164	e = ( Email) liste[0];
1165	Assert. That( NDOObjectState. Persistent == e. NDOObjectState, "1: Email should be persistent" ) ;
1166	Assert. That( e. Schlüssel != null, "2. Relation is missing" ) ;
1167	Assert. That( NDOObjectState. Persistent == e. Schlüssel. NDOObjectState, "2. : Zertifikat should be hollow" ) ;
1168	Assert. That( Object. ReferenceEquals( e, z0. Adresse ) , "2. Backlink wrong" ) ;
1169
1170	················pm.UnloadCache();
1171	················liste = pm.GetClassExtent( typeof( Email ) );
1172	e = ( Email) liste[0];
1173	Assert. That( NDOObjectState. Hollow == e. NDOObjectState, "5: Email should be hollow" ) ;
1174	Assert. That( e. Schlüssel != null, "6. Relation is missing" ) ;
1175	Assert. That( NDOObjectState. Hollow == e. Schlüssel. NDOObjectState, "8. : Zertifikat should be hollow" ) ;
1176	················Assert.That( e != z0.Adresse, "8a. Should be different objects" );
1177	Assert. That( Object. ReferenceEquals( e, e. Schlüssel. Adresse ) , "8b. Email should match" ) ;
1178
1179	················pm.UnloadCache();
1180	················liste = pm.GetClassExtent( typeof( Email ), false );
1181	e = ( Email) liste[0];
1182	Assert. That( NDOObjectState. Persistent == e. NDOObjectState, "9: Email should be persistent" ) ;
1183	Assert. That( e. Schlüssel != null, "10. Relation is missing" ) ;
1184	Assert. That( NDOObjectState. Hollow == e. Schlüssel. NDOObjectState, "12. : Zertifikat should be hollow" ) ;
1185	················Assert.That( e != z0.Adresse, "12a. Should be different objects" );
1186	Assert. That( Object. ReferenceEquals( e, e. Schlüssel. Adresse ) , "12b. Email should match" ) ;
1187	············}
1188	········}
1189
1190	········[Test]
1191	········public void BiTest()
1192	········{
1193	············using (var pm = PmFactory.NewPersistenceManager())
1194	············{

1195	················pm.MakePersistent( e );
1196	················pm.MakePersistent( z0 );
1197	················//············System.Diagnostics.Debug.WriteLine("e:" + e.NDOObjectId.ExpressionString);
1198	················//············System.Diagnostics.Debug.WriteLine("z:" + z.NDOObjectId.ExpressionString);
1199	················e.Schlüssel = this.z0;
1200	················pm.Save();
1201	················//············System.Diagnostics.Debug.WriteLine("e:" + e.NDOObjectId.ExpressionString);
1202	················//············System.Diagnostics.Debug.WriteLine("z:" + z.NDOObjectId.ExpressionString);
1203
1204	············}
1205	········}
1206

1207	········#endregion







1208
1209	········private Mitarbeiter CreateMitarbeiter( string vorname, string nachname )
1210	········{
1211	············Mitarbeiter m = new Mitarbeiter();
1212	············m.Vorname = vorname;
1213	············m.Nachname = nachname;
1214	············return m;
1215	········}
1216	····}
1217	}
1218

Cookie Info