Datei: IntegrationTests/IntegrationTests/Rel1to1Directed.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 NDO;
29	using NDO.Query;
30	using NDO.Linq;
31
32	namespace NdoUnitTests
33	{
34	····/// <summary>
35	····/// All tests for directed 1:1-Relations. Composition and Assoziation
36	····/// </summary>
37
38
39	····[TestFixture]
40	····public class Rel1to1Directed : NDOTest
41	····{
42	········public Rel1to1Directed()
43	········{
44	········}
45
46	········private PersistenceManager pm;
47	········private Mitarbeiter m;
48	········private Adresse a;
49	········private Buero b;
50
51	········[SetUp]
52	········public void Setup()
53	········{
54	············pm = PmFactory.NewPersistenceManager();
55	············m = CreateMitarbeiter( "Mirko", "Matytschak" );
56	············a = CreateAdresse( "D", "83646", "Nockhergasse 7", "Bad Tölz" );
57	············b = CreateBuero( "3-0815" );
58	········}
59
60	········[TearDown]
61	········public void TearDown()
62	········{
63
64	············pm.Abort();
65	············IList mitarbeiterListe = pm.GetClassExtent( typeof( Mitarbeiter ), true );
66	············pm.Delete( mitarbeiterListe );
67	············IList bueroListe = pm.GetClassExtent( typeof( Buero ), true );
68	············pm.Delete( bueroListe );
69	············IList adressListe = pm.GetClassExtent( typeof( Adresse ), true );
70	············pm.Delete( adressListe );
71	············pm.Save();

72
73	pm. Close( ) ;
74	pm = null;


75	········}
76
77
78	········[Test]
79	········public void TestCreateObjects()
80	········{
81	············pm.MakePersistent( m );
82	············pm.MakePersistent( a );
83	············pm.MakePersistent( b );
84	············if (!pm.HasOwnerCreatedIds)
85	············{
86	················if (m.NDOObjectId.Id[0] is Int32)
87	····················Assert.That(-1 == (int) m.NDOObjectId.Id[0], "Mitarbeiter key wrong" );
88	················if (a.NDOObjectId.Id[0] is Int32)
89	····················Assert.That(-1 == (int) a.NDOObjectId.Id[0], "Adresse key wrong" );
90	················if (b.NDOObjectId.Id[0] is Int32)
91	····················Assert.That(-1 == (int) b.NDOObjectId.Id[0], "Büro key wrong" );
92	············}
93	············Assert.That( !m.NDOObjectId.Equals( a.NDOObjectId ), "Ids should be different m-a" );
94	············Assert.That( !m.NDOObjectId.Equals( b.NDOObjectId ), "Ids should be different m-b" );
95	············Assert.That( !a.NDOObjectId.Equals( b.NDOObjectId ), "Ids should be different a-b" );
96	············m = (Mitarbeiter)pm.FindObject( m.NDOObjectId );
97	············a = (Adresse)pm.FindObject( a.NDOObjectId );
98	············b = (Buero)pm.FindObject( b.NDOObjectId );
99	········}
100
101	········#region Composition Tests
102
103	········[Test]
104	········public void CompTestCreateObjectsSave()
105	········{
106	············m.Adresse = a;
107	············pm.MakePersistent( m );
108	············pm.Save();
109	············Assert.That( !m.NDOObjectId.Equals( a.NDOObjectId ), "Ids should be different" );
110	············m = pm.Objects<Mitarbeiter>().Where(e=>e.Oid() == m.NDOObjectId.Id.Value ).SingleOrDefault();
111	············a = (Adresse)pm.FindObject( a.NDOObjectId );
112	············Assert.That(m != null, "1. Mitarbeiter not found" );
113	············Assert.That(a != null, "1. Adresse not found" );
114	············ObjectId moid = m.NDOObjectId;
115	············ObjectId aoid = a.NDOObjectId;
116	············m = null;
117	············a = null;
118
119	············pm.UnloadCache();
120	············m = pm.Objects<Mitarbeiter>().Where( e=>e.NDOObjectId == moid ).SingleOrDefault();
121	············Adresse a2 = m.Adresse;
122	············a = pm.Objects<Adresse>().Where( x=>x.NDOObjectId == aoid ).SingleOrDefault();
123	············Assert.That(m != null, "2. Mitarbeiter not found" );
124	············Assert.That(a != null, "2. Adresse not found" );
125	············Assert.That(Object.ReferenceEquals(a, a2), "Address should match" );
126	········}
127
128	········[Test]
129	········public void CompTestAddObjectSave()
130	········{
131	············pm.MakePersistent( m );
132	············pm.Save();
133	············m.Adresse = a;
134	············Assert.That(NDOObjectState.Created ==··a.NDOObjectState, "1. Wrong state" );
135	············pm.Save();
136	············m = (Mitarbeiter)pm.FindObject( m.NDOObjectId );
137	············a = (Adresse)pm.FindObject( a.NDOObjectId );
138	············Assert.That(m != null, "1. Mitarbeiter not found" );
139	············Assert.That(a != null, "1. Adresse not found" );
140	············Assert.That(NDOObjectState.Persistent ==··a.NDOObjectState, "2. Wrong state" );
141	········}
142
143	········[Test]
144	········public void CompTestAddObjectAbort()
145	········{
146	············pm.MakePersistent( m );
147	············pm.Save();
148	············m.Adresse = a;
149	············Assert.That(NDOObjectState.Created ==··a.NDOObjectState, "1. Wrong state" );
150	············Assert.That(m.Adresse != null, "1. Adress not found" );
151	············pm.Abort();
152	············Assert.That(NDOObjectState.Transient ==··a.NDOObjectState, "2. Wrong state" );
153	············Assert.That(m.Adresse == null, "1. Adress should be null" );
154	········}
155
156	········[Test]
157	········public void CompTestRemoveObjectSave()
158	········{
159	············pm.MakePersistent( m );
160	············m.Adresse = a;
161	············pm.Save();
162	············Assert.That(m.Adresse != null, "1. Adress not found" );
163	············m.Adresse = null;
164	············Assert.That(NDOObjectState.Deleted ==··a.NDOObjectState, "1. Wrong state" );
165	············Assert.That(m.Adresse == null, "1. Adress should be null" );
166	············pm.Save();
167	············Assert.That(m.Adresse == null, "2. Adress should be null" );
168	············Assert.That(NDOObjectState.Transient ==··a.NDOObjectState, "2. Wrong state" );
169	············ObjectId moid = m.NDOObjectId;
170	············pm.UnloadCache();
171	············m = (Mitarbeiter)pm.FindObject( moid );
172	············Assert.That(m != null, "3. Mitarbeiter not found" );
173	············Assert.That(m.Adresse == null, "3. Adresse should be null" );
174	········}
175
176	········[Test]
177	········public void CompTestRemoveObjectAbort()
178	········{
179	············pm.MakePersistent( m );
180	············m.Adresse = a;
181	············pm.Save();
182	············Assert.That(m.Adresse != null, "1. Adress not found" );
183	············m.Adresse = null;
184	············Assert.That(NDOObjectState.Deleted ==··a.NDOObjectState, "1. Wrong state" );
185	············Assert.That(m.Adresse == null, "2. Adress should be null" );
186	············pm.Abort();
187	············Assert.That(m.Adresse != null, "2. Adress not found" );
188	············Assert.That(NDOObjectState.Persistent ==··a.NDOObjectState, "2. Wrong state" );
189	········}
190
191	········[Test]
192	········public void CompTestDeleteSave()
193	········{
194	············pm.MakePersistent( m );
195	············m.Adresse = a;
196	············pm.Save();
197	············pm.Delete( m );
198	············Assert.That(NDOObjectState.Deleted ==··m.NDOObjectState, "1. Wrong state" );
199	············Assert.That(NDOObjectState.Deleted ==··a.NDOObjectState, "2. Wrong state" );
200	············pm.Save();
201	············Assert.That(NDOObjectState.Transient ==··m.NDOObjectState, "1. Wrong state" );
202	············Assert.That(NDOObjectState.Transient ==··a.NDOObjectState, "2. Wrong state" );
203	········}
204
205
206
207	········[Test]
208	········public void CompTestDeleteAbort()
209	········{
210	············pm.MakePersistent( m );
211	············m.Adresse = a;
212	············pm.Save();
213	············pm.Delete( m );
214	············Assert.That(NDOObjectState.Deleted ==··m.NDOObjectState, "1. Wrong state" );
215	············Assert.That(NDOObjectState.Deleted ==··a.NDOObjectState, "2. Wrong state" );
216	············pm.Abort();
217	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "1. Wrong state" );
218	············Assert.That(NDOObjectState.Persistent ==··a.NDOObjectState, "2. Wrong state" );
219	········}
220
221	········[Test]
222	········public void CompTestAddRemoveSave()
223	········{
224	············pm.MakePersistent( m );
225	············pm.Save();
226	············m.Adresse = a;
227	············m.Adresse = null;
228	············Assert.That(NDOObjectState.Transient ==··a.NDOObjectState, "1. Wrong state" );
229	············pm.Save();
230	············Assert.That(NDOObjectState.Transient ==··a.NDOObjectState, "2. Wrong state" );
231	········}
232
233	········[Test]
234	········public void CompTestAddRemoveAbort()
235	········{
236	············pm.MakePersistent( m );
237	············pm.Save();
238	············m.Adresse = a;
239	············m.Adresse = null;
240	············Assert.That(NDOObjectState.Transient ==··a.NDOObjectState, "1. Wrong state" );
241	············pm.Abort();
242	············Assert.That(NDOObjectState.Transient ==··a.NDOObjectState, "2. Wrong state" );
243	········}
244
245
246
247	········[Test]
248	········public void CompTestHollow()
249	········{
250	············m.Adresse = a;
251	············pm.MakePersistent( m );
252	············pm.Save();
253	············pm.MakeHollow( m ); // setzt m.adresse auf null
254
255	············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "1: Mitarbeiter should be hollow" );
256	············Assert.That(NDOObjectState.Persistent ==··a.NDOObjectState, "1: Adresse should be persistent" );
257
258	············a = m.Adresse; // ruft LoadData för m auf. m.adresse liegt auf dem Cache und ist Persistent
259	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "1: Mitarbeiter should be persistent" );
260	············Assert.That(NDOObjectState.Persistent ==··a.NDOObjectState, "2: Adresse should be persistent" );
261	············ObjectId id = m.NDOObjectId;
262	············pm.Close();
263	············pm = PmFactory.NewPersistenceManager();
264	············m = (Mitarbeiter)pm.FindObject( id );
265	············Assert.That(m != null, "Mitarbeiter not found" );
266	············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "2: Mitarbeiter should be hollow" );
267	············a = m.Adresse;
268	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "2: Mitarbeiter should be persistent" );
269	············Assert.That(a != null, "Adress not found" );
270	············Assert.That(NDOObjectState.Hollow ==··a.NDOObjectState, "1: Adresse should be hollow" );
271	········}
272
273
274	········[Test]
275	········public void CompTestMakeAllHollow()
276	········{
277	············m.Adresse = a;
278	············pm.MakePersistent( m );
279	············pm.Save();
280	············pm.MakeAllHollow();
281	············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "1: Mitarbeiter should be hollow" );
282	············Assert.That(NDOObjectState.Hollow ==··a.NDOObjectState, "1: Adresse should be hollow" );
283	········}
284
285	········[Test]
286	········public void CompTestMakeAllHollowUnsaved()
287	········{
288	············m.Adresse = a;
289	············pm.MakePersistent( m );
290	············pm.MakeAllHollow();··// before save, objects cannot be made hollow. => in locked objects
291	············Assert.That(NDOObjectState.Created ==··m.NDOObjectState, "1: Mitarbeiter should be created" );
292	············Assert.That(NDOObjectState.Created ==··a.NDOObjectState, "1: Adresse should be created" );
293	········}
294
295
296	········[Test]
297	········public void CompTestExtentRelatedObjects()
298	········{
299	············m.Adresse = a;
300	············pm.MakePersistent( m );
301	············pm.Save();
302	············IList liste = pm.GetClassExtent( typeof( Mitarbeiter ) );
303	············m = (Mitarbeiter)liste[0];
304	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "1: Mitarbeiter should be persistent" );
305	············Assert.That(m.Adresse != null, "2. Relation is missing" );
306	············Assert.That(NDOObjectState.Persistent ==··m.Adresse.NDOObjectState, "4.: Adresse should be hollow" );
307
308	············pm.UnloadCache();
309	············liste = pm.GetClassExtent( typeof( Mitarbeiter ) );
310	············m = (Mitarbeiter)liste[0];
311	············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "5: Mitarbeiter should be hollow" );
312	············Assert.That(m.Adresse != null, "6. Relation is missing" );
313	············Assert.That(NDOObjectState.Hollow ==··m.Adresse.NDOObjectState, "8.: Adresse should be hollow" );
314
315	············pm.UnloadCache();
316	············liste = pm.GetClassExtent( typeof( Mitarbeiter ), false );
317	············m = (Mitarbeiter)liste[0];
318	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "9: Mitarbeiter should be persistent" );
319	············Assert.That(m.Adresse != null, "10. Relation is missing" );
320	············Assert.That(NDOObjectState.Hollow ==··m.Adresse.NDOObjectState, "12.: Adresse should be hollow" );
321	········}
322
323	········#endregion
324
325	········#region Assoziation Tests
326
327	········[Test]
328	········public void AssoTestCreateObjectsTransient()
329	········{
330	············m.Zimmer = b;
331	············var thrown = false;
332	············try
333	············{
334	················pm.MakePersistent( m );
335	············}
336	············catch (NDOException)
337	············{
338	················thrown = true;
339	············}
340	············Assert.That(true ==··thrown );
341	········}
342
343	········[Test]
344	········public void AssoTestCreateObjectsTransient2()
345	········{
346	············pm.MakePersistent( m );
347	············var thrown = false;
348	············try
349	············{
350	················m.Zimmer = b;
351	············}
352	············catch (NDOException)
353	············{
354	················thrown = true;
355	············}
356	············Assert.That(true ==··thrown );
357	········}
358
359	········[Test]
360	········public void AssoTestCreateObjectsSave()
361	········{
362	············pm.MakePersistent( b );
363	············m.Zimmer = b;
364	············pm.MakePersistent( m );
365	············pm.Save();
366	············Assert.That( !m.NDOObjectId.Equals( b.NDOObjectId ), "Ids should be different" );
367	············m = (Mitarbeiter)pm.FindObject( m.NDOObjectId );
368	············b = (Buero)pm.FindObject( b.NDOObjectId );
369	············Assert.That(m != null, "1. Mitarbeiter not found" );
370	············Assert.That(b != null, "1. Büro not found" );
371	············ObjectId moid = m.NDOObjectId;
372	············ObjectId boid = b.NDOObjectId;
373	············m = null;
374	············b = null;
375
376	············pm.UnloadCache();
377	············m = (Mitarbeiter)pm.FindObject( moid );
378	············Buero b2 = m.Zimmer;
379	············b = (Buero)pm.FindObject( boid );
380	············Assert.That(m != null, "2. Mitarbeiter not found" );
381	············Assert.That(b != null, "2. Adresse not found" );
382	············Assert.That(Object.ReferenceEquals(b, b2), "Büro should match" );
383	········}
384
385	········[Test]
386	········public void AssoTestCreateObjectsSave2()
387	········{
388	············pm.MakePersistent( b );
389	············pm.Save();
390	············m.Zimmer = b;
391	············pm.MakePersistent( m );
392	············pm.Save();
393	············Assert.That( !m.NDOObjectId.Equals( b.NDOObjectId ), "Ids should be different" );
394	············m = (Mitarbeiter)pm.FindObject( m.NDOObjectId );
395	············b = (Buero)pm.FindObject( b.NDOObjectId );
396	········}
397
398	········[Test]
399	········public void AssoTestAddObjectSave()
400	········{
401	············pm.MakePersistent( b );
402	············pm.MakePersistent( m );
403	············pm.Save();
404	············m.Zimmer = b;
405	············Assert.That(NDOObjectState.Persistent ==··b.NDOObjectState, "1. Wrong state" );
406	············Assert.That(NDOObjectState.PersistentDirty ==··m.NDOObjectState, "2. Wrong state" );
407	············pm.Save();
408	············m = (Mitarbeiter)pm.FindObject( m.NDOObjectId );
409	············b = (Buero)pm.FindObject( b.NDOObjectId );
410	············Assert.That(m != null, "1. Mitarbeiter not found" );
411	············Assert.That(b != null, "1. Büro not found" );
412	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "2. Wrong state" );
413	········}
414
415
416
417	········[Test]
418	········public void AssoTestAggregateFunction()
419	········{
420	············pm.MakePersistent( b );
421	············pm.MakePersistent( m );
422	············m.Zimmer = b;
423	············pm.Save();
424	············ObjectId oid = b.NDOObjectId;
425	············pm.UnloadCache();
426	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "meinBuero.oid" + " = " + "{0}" );
427	············q.Parameters.Add( oid.Id[0] );
428	············decimal count = (decimal)q.ExecuteAggregate( m => m.Nachname, AggregateType.Count );
429	············Assert.That( count > 0m, "Count should be > 0" );
430	············m.Zimmer = null;
431	············pm.Save();
432	············pm.UnloadCache();
433	············count = (decimal)q.ExecuteAggregate( m => m.Nachname, AggregateType.Count );
434	············Assert.That(0m ==··count, "Count should be 0" );
435	········}
436
437	········[Test]
438	········public void AssoTestAddObjectAbort()
439	········{
440	············pm.MakePersistent( b );
441	············pm.MakePersistent( m );
442	············pm.Save();
443	············m.Zimmer = b;
444	············Assert.That(NDOObjectState.Persistent ==··b.NDOObjectState, "1. Wrong state" );
445	············Assert.That(m.Zimmer != null, "1. Büro not found" );
446	············pm.Abort();
447	············Assert.That(NDOObjectState.Persistent ==··b.NDOObjectState, "2. Wrong state" );
448	············Assert.That(m.Zimmer == null, "1. Büro should be null" );
449	········}
450
451	········[Test]
452	········public void AssoTestRemoveObjectSave()
453	········{
454	············pm.MakePersistent( b );
455	············pm.MakePersistent( m );
456	············m.Zimmer = b;
457	············pm.Save();
458	············Assert.That(m.Zimmer != null, "1. Büro not found" );
459	············m.Zimmer = null;
460	············Assert.That(NDOObjectState.Persistent ==··b.NDOObjectState, "1. Wrong state" );
461	············Assert.That(m.Zimmer == null, "1. Büro should be null" );
462	············pm.Save();
463	············Assert.That(m.Zimmer == null, "2. Büro should be null" );
464	············Assert.That(NDOObjectState.Persistent ==··b.NDOObjectState, "2. Wrong state" );
465	············ObjectId moid = m.NDOObjectId;
466	············ObjectId boid = b.NDOObjectId;
467	············pm.UnloadCache();
468	············m = (Mitarbeiter)pm.FindObject( moid );
469	············Assert.That(m != null, "3. Mitarbeiter not found" );
470	············Assert.That(m.Zimmer == null, "3. Büro should be null" );
471	············b = (Buero)pm.FindObject( boid );
472	············Assert.That(b != null, "3. Buero not found" );
473	········}
474
475	········[Test]
476	········public void AssoTestRemoveObjectAbort()
477	········{
478	············pm.MakePersistent( b );
479	············pm.MakePersistent( m );
480	············m.Zimmer = b;
481	············pm.Save();
482	············Assert.That(m.Zimmer != null, "1. Büro not found" );
483	············m.Zimmer = null;
484	············Assert.That(NDOObjectState.Persistent ==··b.NDOObjectState, "1. Wrong state" );
485	············Assert.That(m.Zimmer == null, "2. Büro should be null" );
486	············pm.Abort();
487	············Assert.That(m.Zimmer != null, "2. Büro not found" );
488	············Assert.That(NDOObjectState.Persistent ==··b.NDOObjectState, "2. Wrong state" );
489	········}
490
491	········[Test]
492	········public void AssoTestDeleteSave()
493	········{
494	············pm.MakePersistent( b );
495	············pm.MakePersistent( m );
496	············m.Zimmer = b;
497	············pm.Save();
498	············pm.Delete( m );
499	············Assert.That(NDOObjectState.Deleted ==··m.NDOObjectState, "1. Wrong state" );
500	············Assert.That(NDOObjectState.Persistent ==··b.NDOObjectState, "2. Wrong state" );
501	············pm.Save();
502	············Assert.That(NDOObjectState.Transient ==··m.NDOObjectState, "1. Wrong state" );
503	············Assert.That(NDOObjectState.Persistent ==··b.NDOObjectState, "2. Wrong state" );
504	········}
505
506
507
508	········[Test]
509	········public void AssoTestDeleteAbort()
510	········{
511	············pm.MakePersistent( b );
512	············pm.MakePersistent( m );
513	············m.Zimmer = b;
514	············pm.Save();
515	············pm.Delete( m );
516	············Assert.That(NDOObjectState.Deleted ==··m.NDOObjectState, "1. Wrong state" );
517	············Assert.That(NDOObjectState.Persistent ==··b.NDOObjectState, "2. Wrong state" );
518	············pm.Abort();
519	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "1. Wrong state" );
520	············Assert.That(NDOObjectState.Persistent ==··b.NDOObjectState, "2. Wrong state" );
521	········}
522
523	········[Test]
524	········public void AssoTestAddRemoveSave()
525	········{
526	············pm.MakePersistent( b );
527	············pm.MakePersistent( m );
528	············pm.Save();
529	············m.Zimmer = b;
530	············m.Zimmer = null;
531	············Assert.That(NDOObjectState.Persistent ==··b.NDOObjectState, "1. Wrong state" );
532	············pm.Save();
533	············Assert.That(NDOObjectState.Persistent ==··b.NDOObjectState, "2. Wrong state" );
534	········}
535
536	········[Test]
537	········public void AssoTestAddRemoveAbort()
538	········{
539	············pm.MakePersistent( b );
540	············pm.MakePersistent( m );
541	············pm.Save();
542	············m.Zimmer = b;
543	············m.Zimmer = null;
544	············Assert.That(NDOObjectState.Persistent ==··b.NDOObjectState, "1. Wrong state" );
545	············pm.Abort();
546	············Assert.That(NDOObjectState.Persistent ==··b.NDOObjectState, "2. Wrong state" );
547	········}
548
549
550
551	········[Test]
552	········public void AssoTestHollow()
553	········{
554	············pm.MakePersistent( b );
555	············m.Zimmer = b;
556	············pm.MakePersistent( m );
557	············pm.Save();
558	············pm.MakeHollow( m ); // setzt m.Zimmer auf null
559
560	············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "1: Mitarbeiter should be hollow" );
561	············Assert.That(NDOObjectState.Persistent ==··b.NDOObjectState, "1: Büro should be persistent" );
562
563	············b = m.Zimmer; // ruft LoadData för m auf. m.Zimmer liegt im Cache und ist Persistent
564	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "1: Mitarbeiter should be persistent" );
565	············Assert.That(NDOObjectState.Persistent ==··b.NDOObjectState, "2: Adresse should be persistent" );
566	············ObjectId id = m.NDOObjectId;
567	············pm.Close();
568	············pm = PmFactory.NewPersistenceManager();
569	············m = (Mitarbeiter)pm.FindObject( id );
570	············Assert.That(m != null, "Mitarbeiter not found" );
571	············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "2: Mitarbeiter should be hollow" );
572	············b = m.Zimmer;
573	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "2: Mitarbeiter should be persistent" );
574	············Assert.That(b != null, "Büro not found" );
575	············Assert.That(NDOObjectState.Hollow ==··b.NDOObjectState, "1: Büro should be hollow" );
576	········}
577
578
579	········[Test]
580	········public void AssoTestMakeAllHollow()
581	········{
582	············pm.MakePersistent( b );
583	············m.Zimmer = b;
584	············pm.MakePersistent( m );
585	············pm.Save();
586	············pm.MakeAllHollow();
587	············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "1: Mitarbeiter should be hollow" );
588	············Assert.That(NDOObjectState.Hollow ==··b.NDOObjectState, "1: Büro should be hollow" );
589	········}
590
591	········[Test]
592	········public void AssoTestMakeAllHollowUnsaved()
593	········{
594	············pm.MakePersistent( b );
595	············m.Zimmer = b;
596	············pm.MakePersistent( m );
597	············pm.MakeAllHollow();··// before save, objects cannot be made hollow. => in locked objects
598	············Assert.That(NDOObjectState.Created ==··m.NDOObjectState, "1: Mitarbeiter should be created" );
599	············Assert.That(NDOObjectState.Created ==··b.NDOObjectState, "1: Büro should be created" );
600	········}
601
602	········[Test]
603	········public void AssoTestMakeAllHollowUnsaved2()
604	········{
605	············pm.MakePersistent( b );
606	············pm.Save();
607	············m.Zimmer = b;
608	············pm.MakePersistent( m );
609	············pm.MakeAllHollow();··// before save, objects cannot be made hollow. => in locked objects
610	············Assert.That(NDOObjectState.Created ==··m.NDOObjectState, "1: Mitarbeiter should be created" );
611	············Assert.That(NDOObjectState.Hollow ==··b.NDOObjectState, "1: Büro should be hollow" );
612	········}
613
614	········[Test]
615	········public void AssoTestExtentRelatedObjects()
616	········{
617	············pm.MakePersistent( b );
618	············m.Zimmer = b;
619	············pm.MakePersistent( m );
620	············pm.Save();
621	············IList liste = pm.GetClassExtent( typeof( Mitarbeiter ) );
622	············m = (Mitarbeiter)liste[0];
623	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "1: Mitarbeiter should be persistent" );
624	············Assert.That(m.Zimmer != null, "2. Relation is missing" );
625	············Assert.That(NDOObjectState.Persistent ==··m.Zimmer.NDOObjectState, "4.: Büro should be hollow" );
626
627	············pm.UnloadCache();
628	············liste = pm.GetClassExtent( typeof( Mitarbeiter ) );
629	············m = (Mitarbeiter)liste[0];
630	············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "5: Mitarbeiter should be hollow" );
631	············Assert.That(m.Zimmer != null, "6. Relation is missing" );
632	············Assert.That(NDOObjectState.Hollow ==··m.Zimmer.NDOObjectState, "8.: Büro should be hollow" );
633
634	············pm.UnloadCache();
635	············liste = pm.GetClassExtent( typeof( Mitarbeiter ), false );
636	············m = (Mitarbeiter)liste[0];
637	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "9: Mitarbeiter should be persistent" );
638	············Assert.That(m.Zimmer != null, "10. Relation is missing" );
639	············Assert.That(NDOObjectState.Hollow ==··m.Zimmer.NDOObjectState, "12.: Büro should be hollow" );
640	········}
641	········#endregion
642
643	········#region Combined Tests
644	········[Test]
645	········public void CombinedTestCreateObjectsSave()
646	········{
647	············pm.MakePersistent( b );
648	············m.Adresse = a;
649	············m.Zimmer = b;
650	············pm.MakePersistent( m );
651	············pm.Save();
652	············Assert.That( !m.NDOObjectId.Equals( a.NDOObjectId ), "Ids should be different" );
653	············m = (Mitarbeiter)pm.FindObject( m.NDOObjectId );
654	············a = (Adresse)pm.FindObject( a.NDOObjectId );
655	············b = (Buero)pm.FindObject( b.NDOObjectId );
656	············Assert.That(m != null, "1. Mitarbeiter not found" );
657	············Assert.That(a != null, "1. Adresse not found" );
658	············Assert.That(b != null, "1. Büro not found" );
659	············ObjectId moid = m.NDOObjectId;
660	············ObjectId aoid = a.NDOObjectId;
661	············ObjectId boid = b.NDOObjectId;
662	············m = null;
663	············a = null;
664	············b = null;
665
666	············pm.UnloadCache();
667	············m = (Mitarbeiter)pm.FindObject( moid );
668	············Assert.That(m != null, "2. Mitarbeiter not found" );
669	············Assert.That(m.Adresse != null, "2. Adresse not found" );
670	············Assert.That(m.Zimmer != null, "2. Büro not found" );
671	········}
672	········[Test]
673	········public void TestForeignKeyConstraint()
674	········{
675	············pm.MakePersistent( b );
676	············pm.Save();
677	············pm.MakePersistent( m );
678	············m.Zimmer = b;
679	············pm.Save();
680	········}
681
682	········[Test]
683	········public void CombinedTestAddAdresse()
684	········{
685	············pm.MakePersistent( b );
686	············m.Zimmer = b;
687	············pm.MakePersistent( m );
688	············pm.Save();
689	············m.Adresse = a;
690	············pm.Save();
691	············ObjectId moid = m.NDOObjectId;
692	············m = null;
693	············a = null;
694	············b = null;
695
696	············pm.UnloadCache();
697	············m = (Mitarbeiter)pm.FindObject( moid );
698	············Assert.That(m != null, "2. Mitarbeiter not found" );
699	············Assert.That(m.Adresse != null, "2. Adresse not found" );
700	············Assert.That(m.Zimmer != null, "2. Büro not found" );
701	········}
702
703	········[Test]
704	········public void CombinedTestAddAdresseRemoveBüro()
705	········{
706	············pm.MakePersistent( b );
707	············m.Zimmer = b;
708	············pm.MakePersistent( m );
709	············pm.Save();
710	············m.Adresse = a;
711	············m.Zimmer = null;
712	············pm.Save();
713	············ObjectId moid = m.NDOObjectId;
714	············ObjectId boid = b.NDOObjectId;
715	············m = null;
716	············a = null;
717	············b = null;
718
719	············pm.UnloadCache();
720	············m = (Mitarbeiter)pm.FindObject( moid );
721	············Assert.That(m != null, "Mitarbeiter not found" );
722	············Assert.That(m.Adresse != null, "Adresse not found" );
723	············Assert.That(m.Zimmer == null, "Unexpected Büro" );
724	············b = (Buero)pm.FindObject( boid );
725	············Assert.That(b != null, "Büro not found" );
726	········}
727
728	········[Test]
729	········public void CombinedTestAddBüroRemoveAdresse()
730	········{
731	············pm.MakePersistent( b );
732	············m.Adresse = a;
733	············pm.MakePersistent( m );
734	············pm.Save();
735	············Adresse adr = a;
736	············m.Zimmer = b;
737	············m.Adresse = null;
738	············pm.Save();
739	············ObjectId moid = m.NDOObjectId;
740	············m = null;
741	············a = null;
742	············b = null;
743
744	············pm.UnloadCache();
745	············m = (Mitarbeiter)pm.FindObject( moid );
746	············Assert.That(m != null, "Mitarbeiter not found" );
747	············Assert.That(m.Zimmer != null, "Büro not found" );
748	············Assert.That(m.Adresse == null, "Unexpected Adresse" );
749	············Assert.That( adr.NDOObjectState == NDOObjectState.Transient, "Adresse should be deleted" );
750	········}
751
752	········[Test]
753	········public void CombinedTestCreateAddRemoveAdresse()
754	········{
755	············pm.MakePersistent( b );
756	············m.Adresse = a;
757	············m.Zimmer = b;
758	············m.Adresse = null;
759	············pm.MakePersistent( m );
760	············pm.Save();
761	············ObjectId moid = m.NDOObjectId;
762	············m = null;
763	············a = null;
764	············b = null;
765
766	············pm.UnloadCache();
767	············m = (Mitarbeiter)pm.FindObject( moid );
768	············Assert.That(m != null, "Mitarbeiter not found" );
769	············Assert.That(m.Zimmer != null, "Büro not found" );
770	············Assert.That(m.Adresse == null, "Unexpected Adresse" );
771	········}
772
773	········[Test]
774	········public void CombinedTestCreateAddRemoveBüro()
775	········{
776	············pm.MakePersistent( b );
777	············m.Zimmer = b;
778	············m.Adresse = a;
779	············m.Zimmer = null;
780	············pm.MakePersistent( m );
781	············pm.Save();
782	············ObjectId moid = m.NDOObjectId;
783	············m = null;
784	············a = null;
785	············b = null;
786
787	············pm.UnloadCache();
788	············m = (Mitarbeiter)pm.FindObject( moid );
789	············Assert.That(m != null, "Mitarbeiter not found" );
790	············Assert.That(m.Adresse != null, "Adresse not found" );
791	············Assert.That(m.Zimmer == null, "Unexpected Büro" );
792	········}
793
794	········[Test]
795	········public void CombinedTestAddRemoveBüro()
796	········{
797	············pm.MakePersistent( b );
798	············m.Adresse = a;
799	············m.Zimmer = null;
800	············pm.MakePersistent( m );
801	············pm.Save();
802	············m.Zimmer = b;
803	············m.Zimmer = null;
804	············pm.Save();
805	············ObjectId moid = m.NDOObjectId;
806	············m = null;
807	············a = null;
808	············b = null;
809
810	············pm.UnloadCache();
811	············m = (Mitarbeiter)pm.FindObject( moid );
812	············Assert.That(m != null, "Mitarbeiter not found" );
813	············Assert.That(m.Adresse != null, "Adresse not found" );
814	············Assert.That(m.Zimmer == null, "Unexpected Büro" );
815	········}
816
817	········[Test]
818	········public void CombinedTestAddBüroRemoveAdresseAbort()
819	········{
820	············pm.MakePersistent( b );
821	············m.Adresse = a;
822	············pm.MakePersistent( m );
823	············pm.Save();
824	············ObjectId aoid = a.NDOObjectId;
825	············m.Zimmer = b;
826	············m.Adresse = null;
827	············pm.Abort();
828	············Assert.That(m != null, "1. Mitarbeiter not found" );
829	············Assert.That(m.Adresse != null, "1. Adresse not found" );
830	············Assert.That(m.Zimmer == null, "1. Unexpected Büro" );
831
832
833	············ObjectId moid = m.NDOObjectId;
834	············m = null;
835	············a = null;
836	············b = null;
837
838	············pm.UnloadCache();
839	············m = (Mitarbeiter)pm.FindObject( moid );
840	············Assert.That(m != null, "2. Mitarbeiter not found" );
841	············Assert.That(m.Adresse != null, "2. Adresse not found" );
842	············Assert.That(m.Zimmer == null, "2. Unexpected Büro" );
843	········}
844	········#endregion
845
846	········private Mitarbeiter CreateMitarbeiter( string vorname, string nachname )
847	········{
848	············Mitarbeiter m = new Mitarbeiter();
849	············m.Vorname = vorname;
850	············m.Nachname = nachname;
851	············return m;
852	········}
853
854	········private Adresse CreateAdresse( string lkz, string plz, string straße, string ort )
855	········{
856	············Adresse a = new Adresse();
857	············a.Lkz = lkz;
858	············a.Plz = plz;
859	············a.Straße = straße;
860	············a.Ort = ort;
861	············return a;
862	········}
863
864	········private Buero CreateBuero( string zimmer )
865	········{
866	············return new Buero( zimmer );
867	········}
868	····}
869	}
870

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 NDO;
29	using NDO.Query;
30	using NDO.Linq;
31
32	namespace NdoUnitTests
33	{
34	····/// <summary>
35	····/// All tests for directed 1:1-Relations. Composition and Assoziation
36	····/// </summary>
37
38
39	····[TestFixture]
40	····public class Rel1to1Directed : NDOTest
41	····{
42	········public Rel1to1Directed()
43	········{
44	········}
45
46	········private PersistenceManager pm;
47	········private Mitarbeiter m;
48	········private Adresse a;
49	········private Buero b;
50
51	········[SetUp]
52	········public void Setup()
53	········{
54	············pm = PmFactory.NewPersistenceManager();
55	············m = CreateMitarbeiter( "Mirko", "Matytschak" );
56	············a = CreateAdresse( "D", "83646", "Nockhergasse 7", "Bad Tölz" );
57	············b = CreateBuero( "3-0815" );
58	········}
59
60	········[TearDown]
61	········public void TearDown()
62	········{

63	············pm.Abort();
64	············IList mitarbeiterListe = pm.GetClassExtent( typeof( Mitarbeiter ), true );
65	············pm.Delete( mitarbeiterListe );
66	············IList bueroListe = pm.GetClassExtent( typeof( Buero ), true );
67	············pm.Delete( bueroListe );
68	············IList adressListe = pm.GetClassExtent( typeof( Adresse ), true );
69	············pm.Delete( adressListe );
70	············pm.Save();
71	········}
72
73	[OneTimeTearDown]
74	public void OneTimeTearDown( )
75	········{
76	············pm.Dispose();
77	········}
78
79
80	········[Test]
81	········public void TestCreateObjects()
82	········{
83	············pm.MakePersistent( m );
84	············pm.MakePersistent( a );
85	············pm.MakePersistent( b );
86	············if (!pm.HasOwnerCreatedIds)
87	············{
88	················if (m.NDOObjectId.Id[0] is Int32)
89	····················Assert.That(-1 == (int) m.NDOObjectId.Id[0], "Mitarbeiter key wrong" );
90	················if (a.NDOObjectId.Id[0] is Int32)
91	····················Assert.That(-1 == (int) a.NDOObjectId.Id[0], "Adresse key wrong" );
92	················if (b.NDOObjectId.Id[0] is Int32)
93	····················Assert.That(-1 == (int) b.NDOObjectId.Id[0], "Büro key wrong" );
94	············}
95	············Assert.That( !m.NDOObjectId.Equals( a.NDOObjectId ), "Ids should be different m-a" );
96	············Assert.That( !m.NDOObjectId.Equals( b.NDOObjectId ), "Ids should be different m-b" );
97	············Assert.That( !a.NDOObjectId.Equals( b.NDOObjectId ), "Ids should be different a-b" );
98	············m = (Mitarbeiter)pm.FindObject( m.NDOObjectId );
99	············a = (Adresse)pm.FindObject( a.NDOObjectId );
100	············b = (Buero)pm.FindObject( b.NDOObjectId );
101	········}
102
103	········#region Composition Tests
104
105	········[Test]
106	········public void CompTestCreateObjectsSave()
107	········{
108	············m.Adresse = a;
109	············pm.MakePersistent( m );
110	············pm.Save();
111	············Assert.That( !m.NDOObjectId.Equals( a.NDOObjectId ), "Ids should be different" );
112	············m = pm.Objects<Mitarbeiter>().Where(e=>e.Oid() == m.NDOObjectId.Id.Value ).SingleOrDefault();
113	············a = (Adresse)pm.FindObject( a.NDOObjectId );
114	············Assert.That(m != null, "1. Mitarbeiter not found" );
115	············Assert.That(a != null, "1. Adresse not found" );
116	············ObjectId moid = m.NDOObjectId;
117	············ObjectId aoid = a.NDOObjectId;
118	············m = null;
119	············a = null;
120
121	············pm.UnloadCache();
122	············m = pm.Objects<Mitarbeiter>().Where( e=>e.NDOObjectId == moid ).SingleOrDefault();
123	············Adresse a2 = m.Adresse;
124	············a = pm.Objects<Adresse>().Where( x=>x.NDOObjectId == aoid ).SingleOrDefault();
125	············Assert.That(m != null, "2. Mitarbeiter not found" );
126	············Assert.That(a != null, "2. Adresse not found" );
127	············Assert.That(Object.ReferenceEquals(a, a2), "Address should match" );
128	········}
129
130	········[Test]
131	········public void CompTestAddObjectSave()
132	········{
133	············pm.MakePersistent( m );
134	············pm.Save();
135	············m.Adresse = a;
136	············Assert.That(NDOObjectState.Created ==··a.NDOObjectState, "1. Wrong state" );
137	············pm.Save();
138	············m = (Mitarbeiter)pm.FindObject( m.NDOObjectId );
139	············a = (Adresse)pm.FindObject( a.NDOObjectId );
140	············Assert.That(m != null, "1. Mitarbeiter not found" );
141	············Assert.That(a != null, "1. Adresse not found" );
142	············Assert.That(NDOObjectState.Persistent ==··a.NDOObjectState, "2. Wrong state" );
143	········}
144
145	········[Test]
146	········public void CompTestAddObjectAbort()
147	········{
148	············pm.MakePersistent( m );
149	············pm.Save();
150	············m.Adresse = a;
151	············Assert.That(NDOObjectState.Created ==··a.NDOObjectState, "1. Wrong state" );
152	············Assert.That(m.Adresse != null, "1. Adress not found" );
153	············pm.Abort();
154	············Assert.That(NDOObjectState.Transient ==··a.NDOObjectState, "2. Wrong state" );
155	············Assert.That(m.Adresse == null, "1. Adress should be null" );
156	········}
157
158	········[Test]
159	········public void CompTestRemoveObjectSave()
160	········{
161	············pm.MakePersistent( m );
162	············m.Adresse = a;
163	············pm.Save();
164	············Assert.That(m.Adresse != null, "1. Adress not found" );
165	············m.Adresse = null;
166	············Assert.That(NDOObjectState.Deleted ==··a.NDOObjectState, "1. Wrong state" );
167	············Assert.That(m.Adresse == null, "1. Adress should be null" );
168	············pm.Save();
169	············Assert.That(m.Adresse == null, "2. Adress should be null" );
170	············Assert.That(NDOObjectState.Transient ==··a.NDOObjectState, "2. Wrong state" );
171	············ObjectId moid = m.NDOObjectId;
172	············pm.UnloadCache();
173	············m = (Mitarbeiter)pm.FindObject( moid );
174	············Assert.That(m != null, "3. Mitarbeiter not found" );
175	············Assert.That(m.Adresse == null, "3. Adresse should be null" );
176	········}
177
178	········[Test]
179	········public void CompTestRemoveObjectAbort()
180	········{
181	············pm.MakePersistent( m );
182	············m.Adresse = a;
183	············pm.Save();
184	············Assert.That(m.Adresse != null, "1. Adress not found" );
185	············m.Adresse = null;
186	············Assert.That(NDOObjectState.Deleted ==··a.NDOObjectState, "1. Wrong state" );
187	············Assert.That(m.Adresse == null, "2. Adress should be null" );
188	············pm.Abort();
189	············Assert.That(m.Adresse != null, "2. Adress not found" );
190	············Assert.That(NDOObjectState.Persistent ==··a.NDOObjectState, "2. Wrong state" );
191	········}
192
193	········[Test]
194	········public void CompTestDeleteSave()
195	········{
196	············pm.MakePersistent( m );
197	············m.Adresse = a;
198	············pm.Save();
199	············pm.Delete( m );
200	············Assert.That(NDOObjectState.Deleted ==··m.NDOObjectState, "1. Wrong state" );
201	············Assert.That(NDOObjectState.Deleted ==··a.NDOObjectState, "2. Wrong state" );
202	············pm.Save();
203	············Assert.That(NDOObjectState.Transient ==··m.NDOObjectState, "1. Wrong state" );
204	············Assert.That(NDOObjectState.Transient ==··a.NDOObjectState, "2. Wrong state" );
205	········}
206
207
208
209	········[Test]
210	········public void CompTestDeleteAbort()
211	········{
212	············pm.MakePersistent( m );
213	············m.Adresse = a;
214	············pm.Save();
215	············pm.Delete( m );
216	············Assert.That(NDOObjectState.Deleted ==··m.NDOObjectState, "1. Wrong state" );
217	············Assert.That(NDOObjectState.Deleted ==··a.NDOObjectState, "2. Wrong state" );
218	············pm.Abort();
219	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "1. Wrong state" );
220	············Assert.That(NDOObjectState.Persistent ==··a.NDOObjectState, "2. Wrong state" );
221	········}
222
223	········[Test]
224	········public void CompTestAddRemoveSave()
225	········{
226	············pm.MakePersistent( m );
227	············pm.Save();
228	············m.Adresse = a;
229	············m.Adresse = null;
230	············Assert.That(NDOObjectState.Transient ==··a.NDOObjectState, "1. Wrong state" );
231	············pm.Save();
232	············Assert.That(NDOObjectState.Transient ==··a.NDOObjectState, "2. Wrong state" );
233	········}
234
235	········[Test]
236	········public void CompTestAddRemoveAbort()
237	········{
238	············pm.MakePersistent( m );
239	············pm.Save();
240	············m.Adresse = a;
241	············m.Adresse = null;
242	············Assert.That(NDOObjectState.Transient ==··a.NDOObjectState, "1. Wrong state" );
243	············pm.Abort();
244	············Assert.That(NDOObjectState.Transient ==··a.NDOObjectState, "2. Wrong state" );
245	········}
246
247
248
249	········[Test]
250	········public void CompTestHollow()
251	········{
252	············m.Adresse = a;
253	············pm.MakePersistent( m );
254	············pm.Save();
255	············pm.MakeHollow( m ); // setzt m.adresse auf null
256
257	············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "1: Mitarbeiter should be hollow" );
258	············Assert.That(NDOObjectState.Persistent ==··a.NDOObjectState, "1: Adresse should be persistent" );
259
260	············a = m.Adresse; // ruft LoadData för m auf. m.adresse liegt auf dem Cache und ist Persistent
261	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "1: Mitarbeiter should be persistent" );
262	············Assert.That(NDOObjectState.Persistent ==··a.NDOObjectState, "2: Adresse should be persistent" );
263	············ObjectId id = m.NDOObjectId;
264	············pm.Close();
265	············pm = PmFactory.NewPersistenceManager();
266	············m = (Mitarbeiter)pm.FindObject( id );
267	············Assert.That(m != null, "Mitarbeiter not found" );
268	············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "2: Mitarbeiter should be hollow" );
269	············a = m.Adresse;
270	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "2: Mitarbeiter should be persistent" );
271	············Assert.That(a != null, "Adress not found" );
272	············Assert.That(NDOObjectState.Hollow ==··a.NDOObjectState, "1: Adresse should be hollow" );
273	········}
274
275
276	········[Test]
277	········public void CompTestMakeAllHollow()
278	········{
279	············m.Adresse = a;
280	············pm.MakePersistent( m );
281	············pm.Save();
282	············pm.MakeAllHollow();
283	············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "1: Mitarbeiter should be hollow" );
284	············Assert.That(NDOObjectState.Hollow ==··a.NDOObjectState, "1: Adresse should be hollow" );
285	········}
286
287	········[Test]
288	········public void CompTestMakeAllHollowUnsaved()
289	········{
290	············m.Adresse = a;
291	············pm.MakePersistent( m );
292	············pm.MakeAllHollow();··// before save, objects cannot be made hollow. => in locked objects
293	············Assert.That(NDOObjectState.Created ==··m.NDOObjectState, "1: Mitarbeiter should be created" );
294	············Assert.That(NDOObjectState.Created ==··a.NDOObjectState, "1: Adresse should be created" );
295	········}
296
297
298	········[Test]
299	········public void CompTestExtentRelatedObjects()
300	········{
301	············m.Adresse = a;
302	············pm.MakePersistent( m );
303	············pm.Save();
304	············IList liste = pm.GetClassExtent( typeof( Mitarbeiter ) );
305	············m = (Mitarbeiter)liste[0];
306	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "1: Mitarbeiter should be persistent" );
307	············Assert.That(m.Adresse != null, "2. Relation is missing" );
308	············Assert.That(NDOObjectState.Persistent ==··m.Adresse.NDOObjectState, "4.: Adresse should be hollow" );
309
310	············pm.UnloadCache();
311	············liste = pm.GetClassExtent( typeof( Mitarbeiter ) );
312	············m = (Mitarbeiter)liste[0];
313	············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "5: Mitarbeiter should be hollow" );
314	············Assert.That(m.Adresse != null, "6. Relation is missing" );
315	············Assert.That(NDOObjectState.Hollow ==··m.Adresse.NDOObjectState, "8.: Adresse should be hollow" );
316
317	············pm.UnloadCache();
318	············liste = pm.GetClassExtent( typeof( Mitarbeiter ), false );
319	············m = (Mitarbeiter)liste[0];
320	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "9: Mitarbeiter should be persistent" );
321	············Assert.That(m.Adresse != null, "10. Relation is missing" );
322	············Assert.That(NDOObjectState.Hollow ==··m.Adresse.NDOObjectState, "12.: Adresse should be hollow" );
323	········}
324
325	········#endregion
326
327	········#region Assoziation Tests
328
329	········[Test]
330	········public void AssoTestCreateObjectsTransient()
331	········{
332	············m.Zimmer = b;
333	············var thrown = false;
334	············try
335	············{
336	················pm.MakePersistent( m );
337	············}
338	············catch (NDOException)
339	············{
340	················thrown = true;
341	············}
342	············Assert.That(true ==··thrown );
343	········}
344
345	········[Test]
346	········public void AssoTestCreateObjectsTransient2()
347	········{
348	············pm.MakePersistent( m );
349	············var thrown = false;
350	············try
351	············{
352	················m.Zimmer = b;
353	············}
354	············catch (NDOException)
355	············{
356	················thrown = true;
357	············}
358	············Assert.That(true ==··thrown );
359	········}
360
361	········[Test]
362	········public void AssoTestCreateObjectsSave()
363	········{
364	············pm.MakePersistent( b );
365	············m.Zimmer = b;
366	············pm.MakePersistent( m );
367	············pm.Save();
368	············Assert.That( !m.NDOObjectId.Equals( b.NDOObjectId ), "Ids should be different" );
369	············m = (Mitarbeiter)pm.FindObject( m.NDOObjectId );
370	············b = (Buero)pm.FindObject( b.NDOObjectId );
371	············Assert.That(m != null, "1. Mitarbeiter not found" );
372	············Assert.That(b != null, "1. Büro not found" );
373	············ObjectId moid = m.NDOObjectId;
374	············ObjectId boid = b.NDOObjectId;
375	············m = null;
376	············b = null;
377
378	············pm.UnloadCache();
379	············m = (Mitarbeiter)pm.FindObject( moid );
380	············Buero b2 = m.Zimmer;
381	············b = (Buero)pm.FindObject( boid );
382	············Assert.That(m != null, "2. Mitarbeiter not found" );
383	············Assert.That(b != null, "2. Adresse not found" );
384	············Assert.That(Object.ReferenceEquals(b, b2), "Büro should match" );
385	········}
386
387	········[Test]
388	········public void AssoTestCreateObjectsSave2()
389	········{
390	············pm.MakePersistent( b );
391	············pm.Save();
392	············m.Zimmer = b;
393	············pm.MakePersistent( m );
394	············pm.Save();
395	············Assert.That( !m.NDOObjectId.Equals( b.NDOObjectId ), "Ids should be different" );
396	············m = (Mitarbeiter)pm.FindObject( m.NDOObjectId );
397	············b = (Buero)pm.FindObject( b.NDOObjectId );
398	········}
399
400	········[Test]
401	········public void AssoTestAddObjectSave()
402	········{
403	············pm.MakePersistent( b );
404	············pm.MakePersistent( m );
405	············pm.Save();
406	············m.Zimmer = b;
407	············Assert.That(NDOObjectState.Persistent ==··b.NDOObjectState, "1. Wrong state" );
408	············Assert.That(NDOObjectState.PersistentDirty ==··m.NDOObjectState, "2. Wrong state" );
409	············pm.Save();
410	············m = (Mitarbeiter)pm.FindObject( m.NDOObjectId );
411	············b = (Buero)pm.FindObject( b.NDOObjectId );
412	············Assert.That(m != null, "1. Mitarbeiter not found" );
413	············Assert.That(b != null, "1. Büro not found" );
414	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "2. Wrong state" );
415	········}
416
417
418
419	········[Test]
420	········public void AssoTestAggregateFunction()
421	········{
422	············pm.MakePersistent( b );
423	············pm.MakePersistent( m );
424	············m.Zimmer = b;
425	············pm.Save();
426	············ObjectId oid = b.NDOObjectId;
427	············pm.UnloadCache();
428	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, "meinBuero.oid" + " = " + "{0}" );
429	············q.Parameters.Add( oid.Id[0] );
430	············decimal count = (decimal)q.ExecuteAggregate( m => m.Nachname, AggregateType.Count );
431	············Assert.That( count > 0m, "Count should be > 0" );
432	············m.Zimmer = null;
433	············pm.Save();
434	············pm.UnloadCache();
435	············count = (decimal)q.ExecuteAggregate( m => m.Nachname, AggregateType.Count );
436	············Assert.That(0m ==··count, "Count should be 0" );
437	········}
438
439	········[Test]
440	········public void AssoTestAddObjectAbort()
441	········{
442	············pm.MakePersistent( b );
443	············pm.MakePersistent( m );
444	············pm.Save();
445	············m.Zimmer = b;
446	············Assert.That(NDOObjectState.Persistent ==··b.NDOObjectState, "1. Wrong state" );
447	············Assert.That(m.Zimmer != null, "1. Büro not found" );
448	············pm.Abort();
449	············Assert.That(NDOObjectState.Persistent ==··b.NDOObjectState, "2. Wrong state" );
450	············Assert.That(m.Zimmer == null, "1. Büro should be null" );
451	········}
452
453	········[Test]
454	········public void AssoTestRemoveObjectSave()
455	········{
456	············pm.MakePersistent( b );
457	············pm.MakePersistent( m );
458	············m.Zimmer = b;
459	············pm.Save();
460	············Assert.That(m.Zimmer != null, "1. Büro not found" );
461	············m.Zimmer = null;
462	············Assert.That(NDOObjectState.Persistent ==··b.NDOObjectState, "1. Wrong state" );
463	············Assert.That(m.Zimmer == null, "1. Büro should be null" );
464	············pm.Save();
465	············Assert.That(m.Zimmer == null, "2. Büro should be null" );
466	············Assert.That(NDOObjectState.Persistent ==··b.NDOObjectState, "2. Wrong state" );
467	············ObjectId moid = m.NDOObjectId;
468	············ObjectId boid = b.NDOObjectId;
469	············pm.UnloadCache();
470	············m = (Mitarbeiter)pm.FindObject( moid );
471	············Assert.That(m != null, "3. Mitarbeiter not found" );
472	············Assert.That(m.Zimmer == null, "3. Büro should be null" );
473	············b = (Buero)pm.FindObject( boid );
474	············Assert.That(b != null, "3. Buero not found" );
475	········}
476
477	········[Test]
478	········public void AssoTestRemoveObjectAbort()
479	········{
480	············pm.MakePersistent( b );
481	············pm.MakePersistent( m );
482	············m.Zimmer = b;
483	············pm.Save();
484	············Assert.That(m.Zimmer != null, "1. Büro not found" );
485	············m.Zimmer = null;
486	············Assert.That(NDOObjectState.Persistent ==··b.NDOObjectState, "1. Wrong state" );
487	············Assert.That(m.Zimmer == null, "2. Büro should be null" );
488	············pm.Abort();
489	············Assert.That(m.Zimmer != null, "2. Büro not found" );
490	············Assert.That(NDOObjectState.Persistent ==··b.NDOObjectState, "2. Wrong state" );
491	········}
492
493	········[Test]
494	········public void AssoTestDeleteSave()
495	········{
496	············pm.MakePersistent( b );
497	············pm.MakePersistent( m );
498	············m.Zimmer = b;
499	············pm.Save();
500	············pm.Delete( m );
501	············Assert.That(NDOObjectState.Deleted ==··m.NDOObjectState, "1. Wrong state" );
502	············Assert.That(NDOObjectState.Persistent ==··b.NDOObjectState, "2. Wrong state" );
503	············pm.Save();
504	············Assert.That(NDOObjectState.Transient ==··m.NDOObjectState, "1. Wrong state" );
505	············Assert.That(NDOObjectState.Persistent ==··b.NDOObjectState, "2. Wrong state" );
506	········}
507
508
509
510	········[Test]
511	········public void AssoTestDeleteAbort()
512	········{
513	············pm.MakePersistent( b );
514	············pm.MakePersistent( m );
515	············m.Zimmer = b;
516	············pm.Save();
517	············pm.Delete( m );
518	············Assert.That(NDOObjectState.Deleted ==··m.NDOObjectState, "1. Wrong state" );
519	············Assert.That(NDOObjectState.Persistent ==··b.NDOObjectState, "2. Wrong state" );
520	············pm.Abort();
521	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "1. Wrong state" );
522	············Assert.That(NDOObjectState.Persistent ==··b.NDOObjectState, "2. Wrong state" );
523	········}
524
525	········[Test]
526	········public void AssoTestAddRemoveSave()
527	········{
528	············pm.MakePersistent( b );
529	············pm.MakePersistent( m );
530	············pm.Save();
531	············m.Zimmer = b;
532	············m.Zimmer = null;
533	············Assert.That(NDOObjectState.Persistent ==··b.NDOObjectState, "1. Wrong state" );
534	············pm.Save();
535	············Assert.That(NDOObjectState.Persistent ==··b.NDOObjectState, "2. Wrong state" );
536	········}
537
538	········[Test]
539	········public void AssoTestAddRemoveAbort()
540	········{
541	············pm.MakePersistent( b );
542	············pm.MakePersistent( m );
543	············pm.Save();
544	············m.Zimmer = b;
545	············m.Zimmer = null;
546	············Assert.That(NDOObjectState.Persistent ==··b.NDOObjectState, "1. Wrong state" );
547	············pm.Abort();
548	············Assert.That(NDOObjectState.Persistent ==··b.NDOObjectState, "2. Wrong state" );
549	········}
550
551
552
553	········[Test]
554	········public void AssoTestHollow()
555	········{
556	············pm.MakePersistent( b );
557	············m.Zimmer = b;
558	············pm.MakePersistent( m );
559	············pm.Save();
560	············pm.MakeHollow( m ); // setzt m.Zimmer auf null
561
562	············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "1: Mitarbeiter should be hollow" );
563	············Assert.That(NDOObjectState.Persistent ==··b.NDOObjectState, "1: Büro should be persistent" );
564
565	············b = m.Zimmer; // ruft LoadData för m auf. m.Zimmer liegt im Cache und ist Persistent
566	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "1: Mitarbeiter should be persistent" );
567	············Assert.That(NDOObjectState.Persistent ==··b.NDOObjectState, "2: Adresse should be persistent" );
568	············ObjectId id = m.NDOObjectId;
569	············pm.Close();
570	············pm = PmFactory.NewPersistenceManager();
571	············m = (Mitarbeiter)pm.FindObject( id );
572	············Assert.That(m != null, "Mitarbeiter not found" );
573	············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "2: Mitarbeiter should be hollow" );
574	············b = m.Zimmer;
575	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "2: Mitarbeiter should be persistent" );
576	············Assert.That(b != null, "Büro not found" );
577	············Assert.That(NDOObjectState.Hollow ==··b.NDOObjectState, "1: Büro should be hollow" );
578	········}
579
580
581	········[Test]
582	········public void AssoTestMakeAllHollow()
583	········{
584	············pm.MakePersistent( b );
585	············m.Zimmer = b;
586	············pm.MakePersistent( m );
587	············pm.Save();
588	············pm.MakeAllHollow();
589	············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "1: Mitarbeiter should be hollow" );
590	············Assert.That(NDOObjectState.Hollow ==··b.NDOObjectState, "1: Büro should be hollow" );
591	········}
592
593	········[Test]
594	········public void AssoTestMakeAllHollowUnsaved()
595	········{
596	············pm.MakePersistent( b );
597	············m.Zimmer = b;
598	············pm.MakePersistent( m );
599	············pm.MakeAllHollow();··// before save, objects cannot be made hollow. => in locked objects
600	············Assert.That(NDOObjectState.Created ==··m.NDOObjectState, "1: Mitarbeiter should be created" );
601	············Assert.That(NDOObjectState.Created ==··b.NDOObjectState, "1: Büro should be created" );
602	········}
603
604	········[Test]
605	········public void AssoTestMakeAllHollowUnsaved2()
606	········{
607	············pm.MakePersistent( b );
608	············pm.Save();
609	············m.Zimmer = b;
610	············pm.MakePersistent( m );
611	············pm.MakeAllHollow();··// before save, objects cannot be made hollow. => in locked objects
612	············Assert.That(NDOObjectState.Created ==··m.NDOObjectState, "1: Mitarbeiter should be created" );
613	············Assert.That(NDOObjectState.Hollow ==··b.NDOObjectState, "1: Büro should be hollow" );
614	········}
615
616	········[Test]
617	········public void AssoTestExtentRelatedObjects()
618	········{
619	············pm.MakePersistent( b );
620	············m.Zimmer = b;
621	············pm.MakePersistent( m );
622	············pm.Save();
623	············IList liste = pm.GetClassExtent( typeof( Mitarbeiter ) );
624	············m = (Mitarbeiter)liste[0];
625	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "1: Mitarbeiter should be persistent" );
626	············Assert.That(m.Zimmer != null, "2. Relation is missing" );
627	············Assert.That(NDOObjectState.Persistent ==··m.Zimmer.NDOObjectState, "4.: Büro should be hollow" );
628
629	············pm.UnloadCache();
630	············liste = pm.GetClassExtent( typeof( Mitarbeiter ) );
631	············m = (Mitarbeiter)liste[0];
632	············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "5: Mitarbeiter should be hollow" );
633	············Assert.That(m.Zimmer != null, "6. Relation is missing" );
634	············Assert.That(NDOObjectState.Hollow ==··m.Zimmer.NDOObjectState, "8.: Büro should be hollow" );
635
636	············pm.UnloadCache();
637	············liste = pm.GetClassExtent( typeof( Mitarbeiter ), false );
638	············m = (Mitarbeiter)liste[0];
639	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "9: Mitarbeiter should be persistent" );
640	············Assert.That(m.Zimmer != null, "10. Relation is missing" );
641	············Assert.That(NDOObjectState.Hollow ==··m.Zimmer.NDOObjectState, "12.: Büro should be hollow" );
642	········}
643	········#endregion
644
645	········#region Combined Tests
646	········[Test]
647	········public void CombinedTestCreateObjectsSave()
648	········{
649	············pm.MakePersistent( b );
650	············m.Adresse = a;
651	············m.Zimmer = b;
652	············pm.MakePersistent( m );
653	············pm.Save();
654	············Assert.That( !m.NDOObjectId.Equals( a.NDOObjectId ), "Ids should be different" );
655	············m = (Mitarbeiter)pm.FindObject( m.NDOObjectId );
656	············a = (Adresse)pm.FindObject( a.NDOObjectId );
657	············b = (Buero)pm.FindObject( b.NDOObjectId );
658	············Assert.That(m != null, "1. Mitarbeiter not found" );
659	············Assert.That(a != null, "1. Adresse not found" );
660	············Assert.That(b != null, "1. Büro not found" );
661	············ObjectId moid = m.NDOObjectId;
662	············ObjectId aoid = a.NDOObjectId;
663	············ObjectId boid = b.NDOObjectId;
664	············m = null;
665	············a = null;
666	············b = null;
667
668	············pm.UnloadCache();
669	············m = (Mitarbeiter)pm.FindObject( moid );
670	············Assert.That(m != null, "2. Mitarbeiter not found" );
671	············Assert.That(m.Adresse != null, "2. Adresse not found" );
672	············Assert.That(m.Zimmer != null, "2. Büro not found" );
673	········}
674	········[Test]
675	········public void TestForeignKeyConstraint()
676	········{
677	············pm.MakePersistent( b );
678	············pm.Save();
679	············pm.MakePersistent( m );
680	············m.Zimmer = b;
681	············pm.Save();
682	········}
683
684	········[Test]
685	········public void CombinedTestAddAdresse()
686	········{
687	············pm.MakePersistent( b );
688	············m.Zimmer = b;
689	············pm.MakePersistent( m );
690	············pm.Save();
691	············m.Adresse = a;
692	············pm.Save();
693	············ObjectId moid = m.NDOObjectId;
694	············m = null;
695	············a = null;
696	············b = null;
697
698	············pm.UnloadCache();
699	············m = (Mitarbeiter)pm.FindObject( moid );
700	············Assert.That(m != null, "2. Mitarbeiter not found" );
701	············Assert.That(m.Adresse != null, "2. Adresse not found" );
702	············Assert.That(m.Zimmer != null, "2. Büro not found" );
703	········}
704
705	········[Test]
706	········public void CombinedTestAddAdresseRemoveBüro()
707	········{
708	············pm.MakePersistent( b );
709	············m.Zimmer = b;
710	············pm.MakePersistent( m );
711	············pm.Save();
712	············m.Adresse = a;
713	············m.Zimmer = null;
714	············pm.Save();
715	············ObjectId moid = m.NDOObjectId;
716	············ObjectId boid = b.NDOObjectId;
717	············m = null;
718	············a = null;
719	············b = null;
720
721	············pm.UnloadCache();
722	············m = (Mitarbeiter)pm.FindObject( moid );
723	············Assert.That(m != null, "Mitarbeiter not found" );
724	············Assert.That(m.Adresse != null, "Adresse not found" );
725	············Assert.That(m.Zimmer == null, "Unexpected Büro" );
726	············b = (Buero)pm.FindObject( boid );
727	············Assert.That(b != null, "Büro not found" );
728	········}
729
730	········[Test]
731	········public void CombinedTestAddBüroRemoveAdresse()
732	········{
733	············pm.MakePersistent( b );
734	············m.Adresse = a;
735	············pm.MakePersistent( m );
736	············pm.Save();
737	············Adresse adr = a;
738	············m.Zimmer = b;
739	············m.Adresse = null;
740	············pm.Save();
741	············ObjectId moid = m.NDOObjectId;
742	············m = null;
743	············a = null;
744	············b = null;
745
746	············pm.UnloadCache();
747	············m = (Mitarbeiter)pm.FindObject( moid );
748	············Assert.That(m != null, "Mitarbeiter not found" );
749	············Assert.That(m.Zimmer != null, "Büro not found" );
750	············Assert.That(m.Adresse == null, "Unexpected Adresse" );
751	············Assert.That( adr.NDOObjectState == NDOObjectState.Transient, "Adresse should be deleted" );
752	········}
753
754	········[Test]
755	········public void CombinedTestCreateAddRemoveAdresse()
756	········{
757	············pm.MakePersistent( b );
758	············m.Adresse = a;
759	············m.Zimmer = b;
760	············m.Adresse = null;
761	············pm.MakePersistent( m );
762	············pm.Save();
763	············ObjectId moid = m.NDOObjectId;
764	············m = null;
765	············a = null;
766	············b = null;
767
768	············pm.UnloadCache();
769	············m = (Mitarbeiter)pm.FindObject( moid );
770	············Assert.That(m != null, "Mitarbeiter not found" );
771	············Assert.That(m.Zimmer != null, "Büro not found" );
772	············Assert.That(m.Adresse == null, "Unexpected Adresse" );
773	········}
774
775	········[Test]
776	········public void CombinedTestCreateAddRemoveBüro()
777	········{
778	············pm.MakePersistent( b );
779	············m.Zimmer = b;
780	············m.Adresse = a;
781	············m.Zimmer = null;
782	············pm.MakePersistent( m );
783	············pm.Save();
784	············ObjectId moid = m.NDOObjectId;
785	············m = null;
786	············a = null;
787	············b = null;
788
789	············pm.UnloadCache();
790	············m = (Mitarbeiter)pm.FindObject( moid );
791	············Assert.That(m != null, "Mitarbeiter not found" );
792	············Assert.That(m.Adresse != null, "Adresse not found" );
793	············Assert.That(m.Zimmer == null, "Unexpected Büro" );
794	········}
795
796	········[Test]
797	········public void CombinedTestAddRemoveBüro()
798	········{
799	············pm.MakePersistent( b );
800	············m.Adresse = a;
801	············m.Zimmer = null;
802	············pm.MakePersistent( m );
803	············pm.Save();
804	············m.Zimmer = b;
805	············m.Zimmer = null;
806	············pm.Save();
807	············ObjectId moid = m.NDOObjectId;
808	············m = null;
809	············a = null;
810	············b = null;
811
812	············pm.UnloadCache();
813	············m = (Mitarbeiter)pm.FindObject( moid );
814	············Assert.That(m != null, "Mitarbeiter not found" );
815	············Assert.That(m.Adresse != null, "Adresse not found" );
816	············Assert.That(m.Zimmer == null, "Unexpected Büro" );
817	········}
818
819	········[Test]
820	········public void CombinedTestAddBüroRemoveAdresseAbort()
821	········{
822	············pm.MakePersistent( b );
823	············m.Adresse = a;
824	············pm.MakePersistent( m );
825	············pm.Save();
826	············ObjectId aoid = a.NDOObjectId;
827	············m.Zimmer = b;
828	············m.Adresse = null;
829	············pm.Abort();
830	············Assert.That(m != null, "1. Mitarbeiter not found" );
831	············Assert.That(m.Adresse != null, "1. Adresse not found" );
832	············Assert.That(m.Zimmer == null, "1. Unexpected Büro" );
833
834
835	············ObjectId moid = m.NDOObjectId;
836	············m = null;
837	············a = null;
838	············b = null;
839
840	············pm.UnloadCache();
841	············m = (Mitarbeiter)pm.FindObject( moid );
842	············Assert.That(m != null, "2. Mitarbeiter not found" );
843	············Assert.That(m.Adresse != null, "2. Adresse not found" );
844	············Assert.That(m.Zimmer == null, "2. Unexpected Büro" );
845	········}
846	········#endregion
847
848	········private Mitarbeiter CreateMitarbeiter( string vorname, string nachname )
849	········{
850	············Mitarbeiter m = new Mitarbeiter();
851	············m.Vorname = vorname;
852	············m.Nachname = nachname;
853	············return m;
854	········}
855
856	········private Adresse CreateAdresse( string lkz, string plz, string straße, string ort )
857	········{
858	············Adresse a = new Adresse();
859	············a.Lkz = lkz;
860	············a.Plz = plz;
861	············a.Straße = straße;
862	············a.Ort = ort;
863	············return a;
864	········}
865
866	········private Buero CreateBuero( string zimmer )
867	········{
868	············return new Buero( zimmer );
869	········}
870	····}
871	}
872

Cookie Info