Datei: IntegrationTests/IntegrationTests/Rel1toNDirectedWTableComposition.cs

Last 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 NDO;
26 using NUnit.Framework;
27 using Reisekosten;
28 using Reisekosten.Personal;
29
30 namespace NdoUnitTests
31 {
32 ····/// <summary>
33 ····/// This class contains all tests for 1:n directed relations with an intermediate mapping table and composition.
34 ····/// </summary>
35 ····[TestFixture]
36 ····public class Rel1toNDirectedWTableComposition : NDOTest
37 ····{
38
39 ········public Rel1toNDirectedWTableComposition()
40 ········{
41 ········}
42
43 ········private PersistenceManager pm;
44 ········private Mitarbeiter m;
45 ········private Email e;
46
47 ········[SetUp]
48 ········public void Setup()
49 ········{
50
51 ············pm = PmFactory.NewPersistenceManager();
52 ············m = CreateMitarbeiter( "Hartmut", "Kocher" );
53 ············e = CreateEmail( "hwk@cortex-brainware.de" );
54 ········}
55
56 ········[TearDown]
57 ········public void TearDown()
58 ········{
59 ············pm.Abort();
60 ············IList mitarbeiterListe = pm.GetClassExtent( typeof( Mitarbeiter ), false );
61 ············pm.Delete( mitarbeiterListe );
62 ············IList eListe = pm.GetClassExtent( typeof( Email ), false );
63 ············pm.Delete( eListe );
64 ············pm.Save();
 
 
 
 
 
 
65 ············pm.Close();
66 ············pm = null;
67 ········}
68
69 ········[Test]
70 ········public void TestCreateObjects()
71 ········{
72 ············pm.MakePersistent( e );
73 ············if (!pm.HasOwnerCreatedIds && e.NDOObjectId.Id[0] is Int32)
74 ················Assert.That(-1 == (int) e.NDOObjectId.Id[0], "Email key wrong" );
75 ············Email r2 = (Email)pm.FindObject( e.NDOObjectId );
76 ············Assert.That(Object.ReferenceEquals(e, r2), "Emails should match" );
77 ········}
78
79 ········[Test]
80 ········public void TestCreateObjectsTransient1()
81 ········{
82 ············m.Hinzufuegen( e );
83 ············pm.MakePersistent( m );
84 ········}
85
86 ········[Test]
87 ········public void TestCreateObjectsTransient2()
88 ········{
89 ············pm.MakePersistent( m );
90 ············m.Hinzufuegen( e );
91 ········}
92
93 ········[Test]
94 ········public void TestCreateObjectsTransient3()
95 ········{
96 ············pm.MakePersistent( e );
97 ············pm.MakePersistent( m );
98 ············var thrown = false;
99 ············try
100 ············{
101 ················m.Hinzufuegen( e ); // Cannot add pers. obj.
102 ············}
103 ············catch (NDOException)
104 ············{
105 ················thrown = true;
106 ············}
107 ············Assert.That(true ==··thrown );
108 ········}
109
110 ········[Test]
111 ········public void TestCreateObjectsTransient4()
112 ········{
113 ············pm.MakePersistent( e );
114 ············m.Hinzufuegen( e );
115 ············var thrown = false;
116 ············try
117 ············{
118 ················pm.MakePersistent( m );
119 ············}
120 ············catch (NDOException)
121 ············{
122 ················thrown = true;
123 ············}
124 ············Assert.That(true ==··thrown );
125 ········}
126
127 ········[Test]
128 ········public void TestCreateObjectsSave()
129 ········{
130 ············m.Hinzufuegen( e );
131 ············pm.MakePersistent( m );
132 ············pm.Save();
133 ············Assert.That( !m.NDOObjectId.Equals( e.NDOObjectId ), "Ids should be different" );
134 ············m = (Mitarbeiter)pm.FindObject( m.NDOObjectId );
135 ············e = (Email)pm.FindObject( e.NDOObjectId );
136 ············Assert.That(m != null, "1. Mitarbeiter not found" );
137 ············Assert.That(e != null, "1. Email not found" );
138
139 ············pm.UnloadCache();
140 ············m = (Mitarbeiter)pm.FindObject( m.NDOObjectId );
141 ············e = (Email)pm.FindObject( e.NDOObjectId );
142 ············Assert.That(m != null, "2. Mitarbeiter not found" );
143 ············Assert.That(e != null, "2. Email not found" );
144 ········}
145
146 ········[Test]
147 ········public void TestAddObjectSave()
148 ········{
149 ············pm.MakePersistent( m );
150 ············pm.Save();
151 ············m.Hinzufuegen( e );
152 ············Assert.That(NDOObjectState.Created ==··e.NDOObjectState, "1. Wrong state" );
153 ············pm.Save();
154 ············m = (Mitarbeiter)pm.FindObject( m.NDOObjectId );
155 ············e = (Email)pm.FindObject( e.NDOObjectId );
156 ············Assert.That(m != null, "1. Mitarbeiter not found" );
157 ············Assert.That(e != null, "1. Email not found" );
158 ············Assert.That(NDOObjectState.Persistent ==··e.NDOObjectState, "2. Wrong state" );
159 ········}
160
161 ········[Test]
162 ········public void TestAddObjectAbort()
163 ········{
164 ············pm.MakePersistent( m );
165 ············pm.Save();
166 ············m.Hinzufuegen( e );
167 ············Assert.That(NDOObjectState.Created ==··e.NDOObjectState, "1. Wrong state" );
168 ············Assert.That(1 ==··m.Emails.Count, "1. Wrong number of objects" );
169 ············pm.Abort();
170 ············Assert.That(NDOObjectState.Transient ==··e.NDOObjectState, "2. Wrong state" );
171 ············Assert.That(0 ==··m.Emails.Count, "2. Wrong number of objects" );
172 ········}
173 ········[Test]
174 ········public void TestRemoveObjectSave()
175 ········{
176 ············m.Hinzufuegen( e );
177 ············pm.MakePersistent( m );
178 ············pm.Save();
179 ············Assert.That(1 ==··m.Emails.Count, "1. Wrong number of objects" );
180 ············m.Löschen( e );
181 ············Assert.That(NDOObjectState.Deleted ==··e.NDOObjectState, "1. Wrong state" );
182 ············Assert.That(0 ==··m.Emails.Count, "2. Wrong number of objects" );
183 ············//pm.LogAdapter = new NDO.Logging.ConsoleLogAdapter();
184 ············//pm.VerboseMode = true;
185 ············pm.Save();
186 ············Assert.That(0 ==··m.Emails.Count, "3. Wrong number of objects" );
187 ············Assert.That(NDOObjectState.Transient ==··e.NDOObjectState, "2. Wrong state" );
188 ········}
189
190 ········[Test]
191 ········public void TestRemoveObjectAbort()
192 ········{
193 ············pm.MakePersistent( m );
194 ············m.Hinzufuegen( e );
195 ············pm.Save();
196 ············Assert.That(1 ==··m.Emails.Count, "1. Wrong number of objects" );
197 ············m.Löschen( e );
198 ············Assert.That(NDOObjectState.Deleted ==··e.NDOObjectState, "1. Wrong state" );
199 ············Assert.That(0 ==··m.Emails.Count, "2. Wrong number of objects" );
200 ············pm.Abort();
201 ············Assert.That(1 ==··m.Emails.Count, "3. Wrong number of objects" );
202 ············Assert.That(NDOObjectState.Persistent ==··e.NDOObjectState, "2. Wrong state" );
203 ········}
204
205 ········[Test]
206 ········public void TestDeleteSave()
207 ········{
208 ············pm.MakePersistent( m );
209 ············m.Hinzufuegen( e );
210 ············pm.Save();
211 ············pm.Delete( m );
212 ············Assert.That(NDOObjectState.Deleted ==··m.NDOObjectState, "1. Wrong state" );
213 ············Assert.That(NDOObjectState.Deleted ==··e.NDOObjectState, "2. Wrong state" );
214 ············pm.Save();
215 ············Assert.That(NDOObjectState.Transient ==··m.NDOObjectState, "1. Wrong state" );
216 ············Assert.That(NDOObjectState.Transient ==··e.NDOObjectState, "2. Wrong state" );
217 ········}
218
219
220
221 ········[Test]
222 ········public void TestDeleteAbort()
223 ········{
224 ············pm.MakePersistent( m );
225 ············m.Hinzufuegen( e );
226 ············pm.Save();
227 ············pm.Delete( m );
228 ············Assert.That(NDOObjectState.Deleted ==··m.NDOObjectState, "1. Wrong state" );
229 ············Assert.That(NDOObjectState.Deleted ==··e.NDOObjectState, "2. Wrong state" );
230 ············pm.Abort();
231 ············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "1. Wrong state" );
232 ············Assert.That(NDOObjectState.Persistent ==··e.NDOObjectState, "2. Wrong state" );
233 ········}
234
235 ········[Test]
236 ········public void TestAddRemoveSave()
237 ········{
238 ············pm.MakePersistent( m );
239 ············pm.Save();
240 ············m.Hinzufuegen( e );
241 ············m.Löschen( e );
242 ············Assert.That(NDOObjectState.Transient ==··e.NDOObjectState, "1. Wrong state" );
243 ············pm.Save();
244 ············Assert.That(NDOObjectState.Transient ==··e.NDOObjectState, "2. Wrong state" );
245 ············Assert.That(0 ==··m.Emails.Count, "3. Wrong number of objects" );
246 ········}
247
248 ········[Test]
249 ········public void TestAddRemoveAbort()
250 ········{
251 ············pm.MakePersistent( m );
252 ············pm.Save();
253 ············m.Hinzufuegen( e );
254 ············m.Löschen( e );
255 ············Assert.That(NDOObjectState.Transient ==··e.NDOObjectState, "1. Wrong state" );
256 ············pm.Abort();
257 ············Assert.That(NDOObjectState.Transient ==··e.NDOObjectState, "2. Wrong state" );
258 ············Assert.That(0 ==··m.Emails.Count, "3. Wrong number of objects" );
259 ········}
260
261 ········[Test]
262 ········public void TestClearRelatedObjectsSave()
263 ········{
264 ············for (int i = 0; i < 10; i++)
265 ············{
266 ················Email rb = CreateEmail( i.ToString() );
267 ················m.Hinzufuegen( rb );
268 ············}
269 ············pm.MakePersistent( m );
270 ············pm.Save();
271 ············IList rr = new ArrayList( m.Emails );
272 ············m.LöscheEmails();
273 ············Assert.That(0 ==··m.Emails.Count, "1. Wrong number of objects" );
274 ············for (int i = 0; i < 10; i++)
275 ············{
276 ················Assert.That(NDOObjectState.Deleted ==··((Email)rr[i]).NDOObjectState, "2. Wrong state" );
277 ············}
278 ············pm.Save();
279 ············Assert.That(0 ==··m.Emails.Count, "3. Wrong number of objects" );
280 ············for (int i = 0; i < 10; i++)
281 ············{
282 ················Assert.That(NDOObjectState.Transient ==··((Email)rr[i]).NDOObjectState, "4. Wrong state" );
283 ············}
284 ········}
285
286 ········[Test]
287 ········public void TestClearRelatedObjectsAbort()
288 ········{
289 ············for (int i = 0; i < 10; i++)
290 ············{
291 ················Email rb = CreateEmail( i.ToString() );
292 ················m.Hinzufuegen( rb );
293 ············}
294 ············pm.MakePersistent( m );
295 ············pm.Save();
296 ············IList rr = new ArrayList( m.Emails );
297 ············m.LöscheEmails();
298 ············Assert.That(0 ==··m.Emails.Count, "1. Wrong number of objects" );
299 ············for (int i = 0; i < 10; i++)
300 ············{
301 ················Assert.That(NDOObjectState.Deleted ==··((Email)rr[i]).NDOObjectState, "2. Wrong state" );
302 ············}
303 ············pm.Abort();
304 ············Assert.That(10 ==··m.Emails.Count, "3. Wrong number of objects" );
305 ············for (int i = 0; i < 10; i++)
306 ············{
307 ················Assert.That(NDOObjectState.Persistent ==··((Email)rr[i]).NDOObjectState, "4. Wrong state" );
308 ············}
309 ········}
310
311
312 ········[Test]
313 ········public void TestHollow()
314 ········{
315 ············m.Hinzufuegen( e );
316 ············pm.MakePersistent( m );
317 ············pm.Save();
318 ············pm.MakeHollow( m );
319 ············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "1: Mitarbeiter should be hollow" );
320 ············Assert.That(NDOObjectState.Persistent ==··e.NDOObjectState, "1: Email should be persistent" );
321 ············IList Email = m.Emails;
322
323 ············pm.MakeHollow( m, true );
324 ············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "2: Mitarbeiter should be hollow" );
325 ············Assert.That(NDOObjectState.Hollow ==··e.NDOObjectState, "2: Email should be hollow" );
326
327 ············Email = m.Emails;
328 ············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "3: Mitarbeiter should be persistent" );
329 ············Assert.That(NDOObjectState.Hollow ==··e.NDOObjectState, "3: Email should be hollow" );
330 ············Assert.That("hwk@cortex-brainware.de" ==··e.Adresse, "3: Email should have correct Adresse" );
331 ············Assert.That(NDOObjectState.Persistent ==··e.NDOObjectState, "4: Email should be persistent" );
332 ········}
333
334 ········[Test]
335 ········public void TestMakeAllHollow()
336 ········{
337 ············m.Hinzufuegen( e );
338 ············pm.MakePersistent( m );
339 ············pm.Save();
340 ············pm.MakeAllHollow();
341 ············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "1: Mitarbeiter should be hollow" );
342 ············Assert.That(NDOObjectState.Hollow ==··e.NDOObjectState, "1: Email should be hollow" );
343 ········}
344
345 ········[Test]
346 ········public void TestMakeAllHollowUnsaved()
347 ········{
348 ············m.Hinzufuegen( e );
349 ············pm.MakePersistent( m );
350 ············pm.MakeAllHollow();··// before save, objects cannot be made hollow. => in locked objects
351 ············Assert.That(NDOObjectState.Created ==··m.NDOObjectState, "1: Mitarbeiter should be created" );
352 ············Assert.That(NDOObjectState.Created ==··e.NDOObjectState, "1: Email should be created" );
353 ········}
354
355 ········[Test]
356 ········public void TestLoadRelatedObjects()
357 ········{
358 ············for (int i = 0; i < 10; i++)
359 ············{
360 ················Email rb = CreateEmail( i.ToString() );
361 ················m.Hinzufuegen( rb );
362 ············}
363 ············pm.MakePersistent( m );
364 ············pm.Save();
365 ············pm.MakeHollow( m, true );
366
367 ············IList Emails = new ArrayList( m.Emails );
368 ············Assert.That(10 ==··Emails.Count, "List size should be 10" );
369
370 ············for (int i = 0; i < 10; i++)
371 ············{
372 ················Email rr = (Email)Emails[i];
373 ················Assert.That(NDOObjectState.Hollow ==··rr.NDOObjectState, "1: Email should be hollow" );
374 #if !ORACLE && !MYSQL && !FIREBIRD
375 ················Assert.That(i.ToString() ==··rr.Adresse, "2: Email should be in right order" );
376 #endif
377 ············}
378
379
380 ············pm.MakeAllHollow();
381 ············pm.UnloadCache();
382 ············IList Reisebüros2 = m.Emails;
383 ············for (int i = 0; i < 10; i++)
384 ············{
385 ················Email r1 = (Email)Emails[i];
386 ················Email r2 = (Email)Reisebüros2[i];
387 #if !ORACLE && !MYSQL && !FIREBIRD
388 ················Assert.That(i.ToString() ==··r1.Adresse, "3: Email should be in right order" );
389 #endif
390 ················Assert.That( r1 != r2, "Objects should be different" );
391 ············}
392 ········}
393
394 ········[Test]
395 ········public void TestLoadRelatedObjectsSave()
396 ········{
397 ············pm.MakePersistent( m );
398 ············pm.Save();
399 ············for (int i = 0; i < 10; i++)
400 ············{
401 ················Email rb = CreateEmail( i.ToString() );
402 ················m.Hinzufuegen( rb );
403 ············}
404 ············pm.Save();
405 ············pm.MakeHollow( m, true );
406
407 ············IList Emails = new ArrayList( m.Emails );
408
409 ············for (int i = 0; i < 10; i++)
410 ············{
411 ················Email rr = (Email)Emails[i];
412 ················Assert.That(NDOObjectState.Hollow ==··rr.NDOObjectState, "1: Email should be hollow" );
413 #if !ORACLE && !MYSQL && !FIREBIRD
414 ················Assert.That(i.ToString() ==··rr.Adresse, "2: Email should be in right order" );
415 #endif
416 ············}
417
418
419 ············pm.MakeAllHollow();
420 ············pm.UnloadCache();
421 ············IList Reisebüros2 = m.Emails;
422 ············for (int i = 0; i < 10; i++)
423 ············{
424 ················Email r1 = (Email)Emails[i];
425 ················Email r2 = (Email)Reisebüros2[i];
426 #if !ORACLE && !MYSQL && !FIREBIRD
427 ················Assert.That(i.ToString() ==··r1.Adresse, "3: Email should be in right order" );
428 #endif
429 ················Assert.That( r1 != r2, "Objects should be different" );
430 ············}
431 ········}
432
433 ········[Test]
434 ········public void TestExtentRelatedObjects()
435 ········{
436 ············m.Hinzufuegen( e );
437 ············pm.MakePersistent( m );
438 ············pm.Save();
439 ············IList liste = pm.GetClassExtent( typeof( Mitarbeiter ) );
440 ············m = (Mitarbeiter)liste[0];
441 ············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "1: Mitarbeiter should be persistent" );
442 ············Assert.That(m.Emails != null, "2. Relation is missing" );
443 ············Assert.That(1 ==··m.Emails.Count, "3. Wrong number of objects" );
444 ············Assert.That(NDOObjectState.Persistent ==··((Email)m.Emails[0]).NDOObjectState, "4.: Email should be persistent" );
445
446 ············pm.UnloadCache();
447 ············liste = pm.GetClassExtent( typeof( Mitarbeiter ) );
448 ············m = (Mitarbeiter)liste[0];
449 ············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "5: Mitarbeiter should be hollow" );
450 ············Assert.That(m.Emails != null, "6. Relation is missing" );
451 ············Assert.That(1 ==··m.Emails.Count, "7. Wrong number of objects" );
452 ············Assert.That(NDOObjectState.Hollow ==··((Email)m.Emails[0]).NDOObjectState, "8.: Email should be hollow" );
453
454 ············pm.UnloadCache();
455 ············liste = pm.GetClassExtent( typeof( Mitarbeiter ), false );
456 ············m = (Mitarbeiter)liste[0];
457 ············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "9: Mitarbeiter should be persistent" );
458 ············Assert.That(m.Emails != null, "10. Relation is missing" );
459 ············Assert.That(1 ==··m.Emails.Count, "11. Wrong number of objects" );
460 ············Assert.That(NDOObjectState.Hollow ==··((Email)m.Emails[0]).NDOObjectState, "12.: Email should be hollow" );
461 ········}
462
463 ········private Mitarbeiter CreateMitarbeiter( string vorname, string nachname )
464 ········{
465 ············Mitarbeiter m = new Mitarbeiter();
466 ············m.Vorname = vorname;
467 ············m.Nachname = nachname;
468 ············return m;
469 ········}
470
471 ········private Email CreateEmail( string Adresse )
472 ········{
473 ············Email e = new Email();
474 ············e.Adresse = Adresse;
475 ············return e;
476 ········}
477 ····}
478 }
479
New Commit (ab2cdbc)
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 NDO;
26 using NUnit.Framework;
27 using Reisekosten;
28 using Reisekosten.Personal;
29
30 namespace NdoUnitTests
31 {
32 ····/// <summary>
33 ····/// This class contains all tests for 1:n directed relations with an intermediate mapping table and composition.
34 ····/// </summary>
35 ····[TestFixture]
36 ····public class Rel1toNDirectedWTableComposition : NDOTest
37 ····{
38
39 ········public Rel1toNDirectedWTableComposition()
40 ········{
41 ········}
42
43 ········private PersistenceManager pm;
44 ········private Mitarbeiter m;
45 ········private Email e;
46
47 ········[SetUp]
48 ········public void Setup()
49 ········{
50
51 ············pm = PmFactory.NewPersistenceManager();
52 ············m = CreateMitarbeiter( "Hartmut", "Kocher" );
53 ············e = CreateEmail( "hwk@cortex-brainware.de" );
54 ········}
55
56 ········[TearDown]
57 ········public void TearDown()
58 ········{
59 ············pm.Abort();
60 ············IList mitarbeiterListe = pm.GetClassExtent( typeof( Mitarbeiter ), false );
61 ············pm.Delete( mitarbeiterListe );
62 ············IList eListe = pm.GetClassExtent( typeof( Email ), false );
63 ············pm.Delete( eListe );
64 ············pm.Save();
65 ········}
66
67
68 ········[OneTimeTearDown]
69 ········public void OneTimeTearDown()
70 ········{
71 ············pm.Close();
72 ············pm = null;
73 ········}
74
75 ········[Test]
76 ········public void TestCreateObjects()
77 ········{
78 ············pm.MakePersistent( e );
79 ············if (!pm.HasOwnerCreatedIds && e.NDOObjectId.Id[0] is Int32)
80 ················Assert.That(-1 == (int) e.NDOObjectId.Id[0], "Email key wrong" );
81 ············Email r2 = (Email)pm.FindObject( e.NDOObjectId );
82 ············Assert.That(Object.ReferenceEquals(e, r2), "Emails should match" );
83 ········}
84
85 ········[Test]
86 ········public void TestCreateObjectsTransient1()
87 ········{
88 ············m.Hinzufuegen( e );
89 ············pm.MakePersistent( m );
90 ········}
91
92 ········[Test]
93 ········public void TestCreateObjectsTransient2()
94 ········{
95 ············pm.MakePersistent( m );
96 ············m.Hinzufuegen( e );
97 ········}
98
99 ········[Test]
100 ········public void TestCreateObjectsTransient3()
101 ········{
102 ············pm.MakePersistent( e );
103 ············pm.MakePersistent( m );
104 ············var thrown = false;
105 ············try
106 ············{
107 ················m.Hinzufuegen( e ); // Cannot add pers. obj.
108 ············}
109 ············catch (NDOException)
110 ············{
111 ················thrown = true;
112 ············}
113 ············Assert.That(true ==··thrown );
114 ········}
115
116 ········[Test]
117 ········public void TestCreateObjectsTransient4()
118 ········{
119 ············pm.MakePersistent( e );
120 ············m.Hinzufuegen( e );
121 ············var thrown = false;
122 ············try
123 ············{
124 ················pm.MakePersistent( m );
125 ············}
126 ············catch (NDOException)
127 ············{
128 ················thrown = true;
129 ············}
130 ············Assert.That(true ==··thrown );
131 ········}
132
133 ········[Test]
134 ········public void TestCreateObjectsSave()
135 ········{
136 ············m.Hinzufuegen( e );
137 ············pm.MakePersistent( m );
138 ············pm.Save();
139 ············Assert.That( !m.NDOObjectId.Equals( e.NDOObjectId ), "Ids should be different" );
140 ············m = (Mitarbeiter)pm.FindObject( m.NDOObjectId );
141 ············e = (Email)pm.FindObject( e.NDOObjectId );
142 ············Assert.That(m != null, "1. Mitarbeiter not found" );
143 ············Assert.That(e != null, "1. Email not found" );
144
145 ············pm.UnloadCache();
146 ············m = (Mitarbeiter)pm.FindObject( m.NDOObjectId );
147 ············e = (Email)pm.FindObject( e.NDOObjectId );
148 ············Assert.That(m != null, "2. Mitarbeiter not found" );
149 ············Assert.That(e != null, "2. Email not found" );
150 ········}
151
152 ········[Test]
153 ········public void TestAddObjectSave()
154 ········{
155 ············pm.MakePersistent( m );
156 ············pm.Save();
157 ············m.Hinzufuegen( e );
158 ············Assert.That(NDOObjectState.Created ==··e.NDOObjectState, "1. Wrong state" );
159 ············pm.Save();
160 ············m = (Mitarbeiter)pm.FindObject( m.NDOObjectId );
161 ············e = (Email)pm.FindObject( e.NDOObjectId );
162 ············Assert.That(m != null, "1. Mitarbeiter not found" );
163 ············Assert.That(e != null, "1. Email not found" );
164 ············Assert.That(NDOObjectState.Persistent ==··e.NDOObjectState, "2. Wrong state" );
165 ········}
166
167 ········[Test]
168 ········public void TestAddObjectAbort()
169 ········{
170 ············pm.MakePersistent( m );
171 ············pm.Save();
172 ············m.Hinzufuegen( e );
173 ············Assert.That(NDOObjectState.Created ==··e.NDOObjectState, "1. Wrong state" );
174 ············Assert.That(1 ==··m.Emails.Count, "1. Wrong number of objects" );
175 ············pm.Abort();
176 ············Assert.That(NDOObjectState.Transient ==··e.NDOObjectState, "2. Wrong state" );
177 ············Assert.That(0 ==··m.Emails.Count, "2. Wrong number of objects" );
178 ········}
179 ········[Test]
180 ········public void TestRemoveObjectSave()
181 ········{
182 ············m.Hinzufuegen( e );
183 ············pm.MakePersistent( m );
184 ············pm.Save();
185 ············Assert.That(1 ==··m.Emails.Count, "1. Wrong number of objects" );
186 ············m.Löschen( e );
187 ············Assert.That(NDOObjectState.Deleted ==··e.NDOObjectState, "1. Wrong state" );
188 ············Assert.That(0 ==··m.Emails.Count, "2. Wrong number of objects" );
189 ············//pm.LogAdapter = new NDO.Logging.ConsoleLogAdapter();
190 ············//pm.VerboseMode = true;
191 ············pm.Save();
192 ············Assert.That(0 ==··m.Emails.Count, "3. Wrong number of objects" );
193 ············Assert.That(NDOObjectState.Transient ==··e.NDOObjectState, "2. Wrong state" );
194 ········}
195
196 ········[Test]
197 ········public void TestRemoveObjectAbort()
198 ········{
199 ············pm.MakePersistent( m );
200 ············m.Hinzufuegen( e );
201 ············pm.Save();
202 ············Assert.That(1 ==··m.Emails.Count, "1. Wrong number of objects" );
203 ············m.Löschen( e );
204 ············Assert.That(NDOObjectState.Deleted ==··e.NDOObjectState, "1. Wrong state" );
205 ············Assert.That(0 ==··m.Emails.Count, "2. Wrong number of objects" );
206 ············pm.Abort();
207 ············Assert.That(1 ==··m.Emails.Count, "3. Wrong number of objects" );
208 ············Assert.That(NDOObjectState.Persistent ==··e.NDOObjectState, "2. Wrong state" );
209 ········}
210
211 ········[Test]
212 ········public void TestDeleteSave()
213 ········{
214 ············pm.MakePersistent( m );
215 ············m.Hinzufuegen( e );
216 ············pm.Save();
217 ············pm.Delete( m );
218 ············Assert.That(NDOObjectState.Deleted ==··m.NDOObjectState, "1. Wrong state" );
219 ············Assert.That(NDOObjectState.Deleted ==··e.NDOObjectState, "2. Wrong state" );
220 ············pm.Save();
221 ············Assert.That(NDOObjectState.Transient ==··m.NDOObjectState, "1. Wrong state" );
222 ············Assert.That(NDOObjectState.Transient ==··e.NDOObjectState, "2. Wrong state" );
223 ········}
224
225
226
227 ········[Test]
228 ········public void TestDeleteAbort()
229 ········{
230 ············pm.MakePersistent( m );
231 ············m.Hinzufuegen( e );
232 ············pm.Save();
233 ············pm.Delete( m );
234 ············Assert.That(NDOObjectState.Deleted ==··m.NDOObjectState, "1. Wrong state" );
235 ············Assert.That(NDOObjectState.Deleted ==··e.NDOObjectState, "2. Wrong state" );
236 ············pm.Abort();
237 ············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "1. Wrong state" );
238 ············Assert.That(NDOObjectState.Persistent ==··e.NDOObjectState, "2. Wrong state" );
239 ········}
240
241 ········[Test]
242 ········public void TestAddRemoveSave()
243 ········{
244 ············pm.MakePersistent( m );
245 ············pm.Save();
246 ············m.Hinzufuegen( e );
247 ············m.Löschen( e );
248 ············Assert.That(NDOObjectState.Transient ==··e.NDOObjectState, "1. Wrong state" );
249 ············pm.Save();
250 ············Assert.That(NDOObjectState.Transient ==··e.NDOObjectState, "2. Wrong state" );
251 ············Assert.That(0 ==··m.Emails.Count, "3. Wrong number of objects" );
252 ········}
253
254 ········[Test]
255 ········public void TestAddRemoveAbort()
256 ········{
257 ············pm.MakePersistent( m );
258 ············pm.Save();
259 ············m.Hinzufuegen( e );
260 ············m.Löschen( e );
261 ············Assert.That(NDOObjectState.Transient ==··e.NDOObjectState, "1. Wrong state" );
262 ············pm.Abort();
263 ············Assert.That(NDOObjectState.Transient ==··e.NDOObjectState, "2. Wrong state" );
264 ············Assert.That(0 ==··m.Emails.Count, "3. Wrong number of objects" );
265 ········}
266
267 ········[Test]
268 ········public void TestClearRelatedObjectsSave()
269 ········{
270 ············for (int i = 0; i < 10; i++)
271 ············{
272 ················Email rb = CreateEmail( i.ToString() );
273 ················m.Hinzufuegen( rb );
274 ············}
275 ············pm.MakePersistent( m );
276 ············pm.Save();
277 ············IList rr = new ArrayList( m.Emails );
278 ············m.LöscheEmails();
279 ············Assert.That(0 ==··m.Emails.Count, "1. Wrong number of objects" );
280 ············for (int i = 0; i < 10; i++)
281 ············{
282 ················Assert.That(NDOObjectState.Deleted ==··((Email)rr[i]).NDOObjectState, "2. Wrong state" );
283 ············}
284 ············pm.Save();
285 ············Assert.That(0 ==··m.Emails.Count, "3. Wrong number of objects" );
286 ············for (int i = 0; i < 10; i++)
287 ············{
288 ················Assert.That(NDOObjectState.Transient ==··((Email)rr[i]).NDOObjectState, "4. Wrong state" );
289 ············}
290 ········}
291
292 ········[Test]
293 ········public void TestClearRelatedObjectsAbort()
294 ········{
295 ············for (int i = 0; i < 10; i++)
296 ············{
297 ················Email rb = CreateEmail( i.ToString() );
298 ················m.Hinzufuegen( rb );
299 ············}
300 ············pm.MakePersistent( m );
301 ············pm.Save();
302 ············IList rr = new ArrayList( m.Emails );
303 ············m.LöscheEmails();
304 ············Assert.That(0 ==··m.Emails.Count, "1. Wrong number of objects" );
305 ············for (int i = 0; i < 10; i++)
306 ············{
307 ················Assert.That(NDOObjectState.Deleted ==··((Email)rr[i]).NDOObjectState, "2. Wrong state" );
308 ············}
309 ············pm.Abort();
310 ············Assert.That(10 ==··m.Emails.Count, "3. Wrong number of objects" );
311 ············for (int i = 0; i < 10; i++)
312 ············{
313 ················Assert.That(NDOObjectState.Persistent ==··((Email)rr[i]).NDOObjectState, "4. Wrong state" );
314 ············}
315 ········}
316
317
318 ········[Test]
319 ········public void TestHollow()
320 ········{
321 ············m.Hinzufuegen( e );
322 ············pm.MakePersistent( m );
323 ············pm.Save();
324 ············pm.MakeHollow( m );
325 ············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "1: Mitarbeiter should be hollow" );
326 ············Assert.That(NDOObjectState.Persistent ==··e.NDOObjectState, "1: Email should be persistent" );
327 ············IList Email = m.Emails;
328
329 ············pm.MakeHollow( m, true );
330 ············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "2: Mitarbeiter should be hollow" );
331 ············Assert.That(NDOObjectState.Hollow ==··e.NDOObjectState, "2: Email should be hollow" );
332
333 ············Email = m.Emails;
334 ············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "3: Mitarbeiter should be persistent" );
335 ············Assert.That(NDOObjectState.Hollow ==··e.NDOObjectState, "3: Email should be hollow" );
336 ············Assert.That("hwk@cortex-brainware.de" ==··e.Adresse, "3: Email should have correct Adresse" );
337 ············Assert.That(NDOObjectState.Persistent ==··e.NDOObjectState, "4: Email should be persistent" );
338 ········}
339
340 ········[Test]
341 ········public void TestMakeAllHollow()
342 ········{
343 ············m.Hinzufuegen( e );
344 ············pm.MakePersistent( m );
345 ············pm.Save();
346 ············pm.MakeAllHollow();
347 ············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "1: Mitarbeiter should be hollow" );
348 ············Assert.That(NDOObjectState.Hollow ==··e.NDOObjectState, "1: Email should be hollow" );
349 ········}
350
351 ········[Test]
352 ········public void TestMakeAllHollowUnsaved()
353 ········{
354 ············m.Hinzufuegen( e );
355 ············pm.MakePersistent( m );
356 ············pm.MakeAllHollow();··// before save, objects cannot be made hollow. => in locked objects
357 ············Assert.That(NDOObjectState.Created ==··m.NDOObjectState, "1: Mitarbeiter should be created" );
358 ············Assert.That(NDOObjectState.Created ==··e.NDOObjectState, "1: Email should be created" );
359 ········}
360
361 ········[Test]
362 ········public void TestLoadRelatedObjects()
363 ········{
364 ············for (int i = 0; i < 10; i++)
365 ············{
366 ················Email rb = CreateEmail( i.ToString() );
367 ················m.Hinzufuegen( rb );
368 ············}
369 ············pm.MakePersistent( m );
370 ············pm.Save();
371 ············pm.MakeHollow( m, true );
372
373 ············IList Emails = new ArrayList( m.Emails );
374 ············Assert.That(10 ==··Emails.Count, "List size should be 10" );
375
376 ············for (int i = 0; i < 10; i++)
377 ············{
378 ················Email rr = (Email)Emails[i];
379 ················Assert.That(NDOObjectState.Hollow ==··rr.NDOObjectState, "1: Email should be hollow" );
380 #if !ORACLE && !MYSQL && !FIREBIRD
381 ················Assert.That(i.ToString() ==··rr.Adresse, "2: Email should be in right order" );
382 #endif
383 ············}
384
385
386 ············pm.MakeAllHollow();
387 ············pm.UnloadCache();
388 ············IList Reisebüros2 = m.Emails;
389 ············for (int i = 0; i < 10; i++)
390 ············{
391 ················Email r1 = (Email)Emails[i];
392 ················Email r2 = (Email)Reisebüros2[i];
393 #if !ORACLE && !MYSQL && !FIREBIRD
394 ················Assert.That(i.ToString() ==··r1.Adresse, "3: Email should be in right order" );
395 #endif
396 ················Assert.That( r1 != r2, "Objects should be different" );
397 ············}
398 ········}
399
400 ········[Test]
401 ········public void TestLoadRelatedObjectsSave()
402 ········{
403 ············pm.MakePersistent( m );
404 ············pm.Save();
405 ············for (int i = 0; i < 10; i++)
406 ············{
407 ················Email rb = CreateEmail( i.ToString() );
408 ················m.Hinzufuegen( rb );
409 ············}
410 ············pm.Save();
411 ············pm.MakeHollow( m, true );
412
413 ············IList Emails = new ArrayList( m.Emails );
414
415 ············for (int i = 0; i < 10; i++)
416 ············{
417 ················Email rr = (Email)Emails[i];
418 ················Assert.That(NDOObjectState.Hollow ==··rr.NDOObjectState, "1: Email should be hollow" );
419 #if !ORACLE && !MYSQL && !FIREBIRD
420 ················Assert.That(i.ToString() ==··rr.Adresse, "2: Email should be in right order" );
421 #endif
422 ············}
423
424
425 ············pm.MakeAllHollow();
426 ············pm.UnloadCache();
427 ············IList Reisebüros2 = m.Emails;
428 ············for (int i = 0; i < 10; i++)
429 ············{
430 ················Email r1 = (Email)Emails[i];
431 ················Email r2 = (Email)Reisebüros2[i];
432 #if !ORACLE && !MYSQL && !FIREBIRD
433 ················Assert.That(i.ToString() ==··r1.Adresse, "3: Email should be in right order" );
434 #endif
435 ················Assert.That( r1 != r2, "Objects should be different" );
436 ············}
437 ········}
438
439 ········[Test]
440 ········public void TestExtentRelatedObjects()
441 ········{
442 ············m.Hinzufuegen( e );
443 ············pm.MakePersistent( m );
444 ············pm.Save();
445 ············IList liste = pm.GetClassExtent( typeof( Mitarbeiter ) );
446 ············m = (Mitarbeiter)liste[0];
447 ············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "1: Mitarbeiter should be persistent" );
448 ············Assert.That(m.Emails != null, "2. Relation is missing" );
449 ············Assert.That(1 ==··m.Emails.Count, "3. Wrong number of objects" );
450 ············Assert.That(NDOObjectState.Persistent ==··((Email)m.Emails[0]).NDOObjectState, "4.: Email should be persistent" );
451
452 ············pm.UnloadCache();
453 ············liste = pm.GetClassExtent( typeof( Mitarbeiter ) );
454 ············m = (Mitarbeiter)liste[0];
455 ············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "5: Mitarbeiter should be hollow" );
456 ············Assert.That(m.Emails != null, "6. Relation is missing" );
457 ············Assert.That(1 ==··m.Emails.Count, "7. Wrong number of objects" );
458 ············Assert.That(NDOObjectState.Hollow ==··((Email)m.Emails[0]).NDOObjectState, "8.: Email should be hollow" );
459
460 ············pm.UnloadCache();
461 ············liste = pm.GetClassExtent( typeof( Mitarbeiter ), false );
462 ············m = (Mitarbeiter)liste[0];
463 ············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "9: Mitarbeiter should be persistent" );
464 ············Assert.That(m.Emails != null, "10. Relation is missing" );
465 ············Assert.That(1 ==··m.Emails.Count, "11. Wrong number of objects" );
466 ············Assert.That(NDOObjectState.Hollow ==··((Email)m.Emails[0]).NDOObjectState, "12.: Email should be hollow" );
467 ········}
468
469 ········private Mitarbeiter CreateMitarbeiter( string vorname, string nachname )
470 ········{
471 ············Mitarbeiter m = new Mitarbeiter();
472 ············m.Vorname = vorname;
473 ············m.Nachname = nachname;
474 ············return m;
475 ········}
476
477 ········private Email CreateEmail( string Adresse )
478 ········{
479 ············Email e = new Email();
480 ············e.Adresse = Adresse;
481 ············return e;
482 ········}
483 ····}
484 }
485