Datei: IntegrationTests/IntegrationTests/ArrayListTests.cs

Last Commit (9d1552b)
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.Reflection;
25 using System.Collections;
26 using NUnit.Framework;
27 using NDO;
28 using Reisekosten;
29 using Reisekosten.Personal;
30 using NDO.Query;
31
32 namespace NdoUnitTests
33 {
34 ····[TestFixture]
35 public class ArrayListTests
36 ····{
37 ········private PersistenceManager pm;
38 ········private Mitarbeiter m;
39 ········private Reise r;
40 ········private Reise r2;
41
42 ········[SetUp]
43 ········public void Setup()
44 ········{
45 ············pm = PmFactory.NewPersistenceManager();
46 ············m = CreateMitarbeiter("Hartmut", "Kocher");
47 ············pm.MakePersistent(m);
48 ············r = CreateReise("ADC");
49 ············r2 = CreateReise("ADW");
50 ········}
51
52 ········[TearDown]
53 ········public void TearDown()
54 ········{
55 ············pm.Abort();
56 ············IList mitarbeiterListe = pm.GetClassExtent( typeof( Mitarbeiter ), true );
57 ············pm.Delete( mitarbeiterListe );
58 ············pm.Save();
59 ············pm.Dispose();
60 ········}
61
62
63 ········private void AddRange()
64 ········{
65 ············ArrayList l = new ArrayList();
66 ············l.Add(r);
67 ············l.Add(r2);
68 ············m.ReisenAddRange(l);
69 ············Assert.That(GetLoadState(), "Relation not loaded");
70 ············pm.Save();
71 ············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "Wrong state #1");
72 ············pm.MakeAllHollow();
73 ············pm.UnloadCache();
74 ············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "Wrong state #2");
75 ············Assert.That(!GetLoadState(), "Relation should not be loaded");
76 ········}
77
78
79 ········[Test]
80 ········public void TestAddRange()
81 ········{
82 ············AddRange();
83 ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm);
84 ············m = q.ExecuteSingle(true);
85 ············Assert.That(2 ==··m.Reisen.Count, "Count of Reisen wrong");
86 ········}
87
88 ········[Test]
89 ········public void TestBinarySearch()
90 ········{
91 ············AddRange();
92 ············int index = m.ReisenBinarySearch(r);
93 ············// Don't care about the result, the object won't be fount
94 ············Assert.That(GetLoadState(), "Relation not loaded");
95 ········}
96
97 ········[Test]
98 ········public void ReisenCapacity()
99 ········{
100 ············AddRange();
101 ············int result = m.ReisenCapacity;
102 ············Assert.That(GetLoadState(), "Relation not loaded");
103 ········}
104
105 ········[Test]
106 ········public void ReisenGetRange()
107 ········{
108 ············AddRange();
109 ············IList l = m.ReisenGetRange(0, 2);
110 ············Assert.That(GetLoadState(), "Relation not loaded");
111 ············Assert.That(2 ==··l.Count, "Count is wrong");
112 ········}
113
114 ········[Test]
115 ········public void ReisenInsertRange()
116 ········{
117 ············AddRange();
118 ············ArrayList range = new ArrayList();
119 ············range.Add(CreateReise("foo"));
120 ············range.Add(CreateReise("bar"));
121 ············m.ReisenInsertRange(1, range);
122 ············Assert.That(GetLoadState(), "Relation not loaded");
123 ············Assert.That(m.Reisen[1] ==··(Reise)range[0], "Wrong order");
124 ············SaveAndReload();
125 ············Assert.That(4 ==··m.Reisen.Count, "Count of Reisen wrong");
126 ········}
127
128 ········[Test]
129 ········public void ReisenLastIndexOf()
130 ········{
131 ············AddRange();
132 ············int i = m.ReisenLastIndexOf(r, 1, 2);
133 ············Assert.That(GetLoadState(), "Relation not loaded");
134 ········}
135
136 ········[Test]
137 ········public void ReisenRemoveRange()
138 ········{
139 ············AddRange();
140 ············m.ReisenRemoveRange(0, 1);
141 ············Assert.That(GetLoadState(), "Relation not loaded");
142 ············Assert.That(1 ==··m.Reisen.Count, "Count of Reisen wrong #1");
143 ············SaveAndReload();
144 ············Assert.That(1 ==··m.Reisen.Count, "Count of Reisen wrong #2");
145 ········}
146
147 ········[Test]
148 ········public void ReisenReverse()
149 ········{
150 ············AddRange();
151 ············m.ReisenReverse();
152 ············Assert.That(GetLoadState(), "Relation not loaded");
153 ········}
154
155 ········//[Test]
156 ········//public void ReisenSetRange()
157 ········//{
158 ········//····AddRange();
159 ········//····ArrayList l = new ArrayList();
160 ········//····l.Add(CreateReise("foo"));
161 ········//····l.Add(CreateReise("bar"));
162 ········//····m.ReisenSetRange(0, l);
163 ····//Assert.That(GetLoadState(), "Relation not loaded");
164 ····//Assert.That("foo" ==··(m.Reisen[0] as Reise).Zweck, "Falsche Reise #1");
165 ····//Assert.That("bar" ==··(m.Reisen[1] as Reise).Zweck, "Falsche Reise #2");
166 ····//····//····SaveAndReload();
167 ····//Assert.That(2 ==··m.Reisen.Count, "Count of Reisen wrong");
168 ····//····//····if (((Reise)m.Reisen[0]).NDOObjectId.Id[0] is Int32)
169 ····//····//····{
170 ····//····//········m.ReisenSort();
171 ····//····Assert.That("bar" ==··(m.Reisen[0] as Reise).Zweck, "Falsche Reise #3");
172 ····//····Assert.That("foo" ==··(m.Reisen[1] as Reise).Zweck, "Falsche Reise #4");
173 ········//····}
174 ········//}
175
176 ········[Test]
177 ········public void ReisenSort()
178 ········{
179 ············AddRange();
180 ············m.ReisenSort();
181 ············Assert.That(GetLoadState(), "Relation not loaded");
182 ········}
183
184 ········[Test]
185 ········public void ReisenToArray()
186 ········{
187 ············AddRange();
188 ············object o = m.ReisenToArray(typeof(Reise));
189 ············Assert.That(GetLoadState(), "Relation not loaded");
190 ········}
191
192 ········//[Test]
193 ········//public void ReisenTrimToSize()
194 ········//{
195 ········//····AddRange();
196 ········//····m.ReisenTrimToSize();
197 ········//Assert.That(GetLoadState(), "Relation not loaded");
198 ········//}
199 ········
200 ········[Test]
201 ········public void ReisenCount()
202 ········{
203 ············AddRange();
204 ············int x = m.ReisenCount;
205 ············Assert.That(GetLoadState(), "Relation not loaded");
206 ········}
207
208 ········[Test]
209 ········public void ReisenContains()
210 ········{
211 ············AddRange();
212 ············bool test = m.ReisenContains(r);
213 ············Assert.That(GetLoadState(), "Relation not loaded");
214 ········}
215
216 ········[Test]
217 ········public void ReisenCopyTo()
218 ········{
219 ············AddRange();
220 ············Reise[] arr = m.ReisenCopyTo;
221 ············Assert.That(GetLoadState(), "Relation not loaded");
222 ············Assert.That((arr[0].Zweck == r.Zweck || arr[0].Zweck == r2.Zweck) && (arr[1].Zweck == r.Zweck || arr[1].Zweck == r2.Zweck), "Reisen not found");
223 ········}
224
225 ········[Test]
226 ········public void ReisenEquals()
227 ········{
228 ············Object o = r;
229 ············AddRange();
230 ············bool dummy = m.ReisenEquals(o);
231 ············Assert.That(GetLoadState(), "Relation not loaded");
232 ········}
233
234 ········[Test]
235 ········public void ReisenEnumerator()
236 ········{
237 ············AddRange();
238 ············IEnumerator ie = m.ReisenEnumerator;
239 ············Assert.That(GetLoadState(), "Relation not loaded");
240 ············ie.MoveNext();
241 ············Assert.That(((Reise)ie.Current).Zweck != r.Zweck ||··((Reise)ie.Current).Zweck != r2.Zweck, "Reise wrong #1");
242 ············ie.MoveNext();
243 ············Assert.That(((Reise)ie.Current).Zweck != r.Zweck ||··((Reise)ie.Current).Zweck != r2.Zweck, "Reise wrong #2");
244 ········}
245
246 ········[Test]
247 ········public void ReisenHashCode()
248 ········{
249 ············AddRange();
250 ············int result = m.ReisenHashCode();
251 ············Assert.That(GetLoadState(), "Relation not loaded");
252 ········}
253
254 ········[Test]
255 ········public void ReisenGetType()
256 ········{
257 ············AddRange();
258 ············Type t = m.ReisenGetType();
259 ············Assert.That(GetLoadState(), "Relation not loaded");
260 ········}
261
262 ········[Test]
263 ········public void ReisenIndexOf()
264 ········{
265 ············AddRange();
266 ············int result = m.ReisenIndexOf(r);
267 ············Assert.That(GetLoadState(), "Relation not loaded");
268 ········}
269
270 ········//[Test]
271 ········//public void ReisenIsFixedSize()
272 ········//{
273 ········//····AddRange();
274 ········//····bool result = m.ReisenIsFixedSize;
275 //····Assert.That(GetLoadState(), "Relation not loaded");
276 ········//}
277
278 ········//[Test]
279 ········//public void ReisenIsReadOnly()
280 ········//{
281 ········//····AddRange();
282 ········//····bool result = m.ReisenIsReadOnly;
283 //·· Assert.That(GetLoadState(), "Relation not loaded");
284 ········//}
285
286
287 ········//[Test]
288 ········//public void ReisenIsSynchronized()
289 ········//{
290 ········//····AddRange();
291 ········//····bool b = m.ReisenIsSynchronized;
292 //····Assert.That(GetLoadState(), "Relation not loaded");
293 ········//}
294
295
296 ········//[Test]
297 ········//public void ReisenSyncRoot()
298 ········//{
299 ········//····AddRange();
300 ········//····object o = m.ReisenSyncRoot;
301 //····Assert.That(GetLoadState(), "Relation not loaded");
302 ········//}
303
304 ········[Test]
305 ········public void ReisenRemoveAt()
306 ········{
307 ············AddRange();
308 ············m.ReisenRemoveAt(1);
309 ············string zweck = ((Reise)m.Reisen[0]).Zweck;
310 ············Assert.That(GetLoadState(), "Relation not loaded");
311 ············SaveAndReload();
312 ············Assert.That(1 ==··m.Reisen.Count, "Wrong count");
313 ············Assert.That(zweck ==··((Reise)m.Reisen[0]).Zweck, "Reise wrong");
314 ········}
315
316 ········[Test]
317 ········public void ReisenToString()
318 ········{
319 ············AddRange();
320 ············string s = m.ReisenToString;
321 ············Assert.That(GetLoadState(), "Relation not loaded");
322 ········}
323
324 ········private Mitarbeiter CreateMitarbeiter(string vorname, string nachname)
325 ········{
326 ············Mitarbeiter m = new Mitarbeiter();
327 ············m.Vorname = vorname;
328 ············m.Nachname = nachname;
329 ············return m;
330 ········}
331
332 ········private Reise CreateReise(string zweck)
333 ········{
334 ············Reise r = new Reise();
335 ············r.Zweck = zweck;
336 ············return r;
337 ········}
338
339 ········private bool GetLoadState()
340 ········{
341 ············NDO.Mapping.Relation r = pm.NDOMapping.FindClass(typeof(Mitarbeiter)).FindRelation("dieReisen");
342 ············FieldInfo fi = typeof(NDO.Mapping.Relation).GetField("Ordinal", BindingFlags.NonPublic | BindingFlags.Instance);
343 ············Assert.That(fi != null);
344 ············object o = fi.GetValue(r);
345 ············Assert.That(o != null);
346 ············return ((IPersistenceCapable)m).NDOGetLoadState((int)o);
347 ········}
348
349 ········private void SaveAndReload()
350 ········{
351 ············pm.Save();
352 ············pm.UnloadCache();
353 ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm);
354 ············m = (Mitarbeiter) q.ExecuteSingle(true);
355 ········}
356
357
358 ····}
359 }
360
New Commit (60cb179)
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.Reflection;
25 using System.Collections;
26 using NUnit.Framework;
27 using NDO;
28 using Reisekosten;
29 using Reisekosten.Personal;
30 using NDO.Query;
31
32 namespace NdoUnitTests
33 {
34 ····[TestFixture]
35 public class ArrayListTests : NDOTest
36 ····{
37 ········private PersistenceManager pm;
38 ········private Mitarbeiter m;
39 ········private Reise r;
40 ········private Reise r2;
41
42 ········[SetUp]
43 ········public void Setup()
44 ········{
45 ············pm = PmFactory.NewPersistenceManager();
46 ············m = CreateMitarbeiter("Hartmut", "Kocher");
47 ············pm.MakePersistent(m);
48 ············r = CreateReise("ADC");
49 ············r2 = CreateReise("ADW");
50 ········}
51
52 ········[TearDown]
53 ········public void TearDown()
54 ········{
55 ············pm.Abort();
56 ············IList mitarbeiterListe = pm.GetClassExtent( typeof( Mitarbeiter ), true );
57 ············pm.Delete( mitarbeiterListe );
58 ············pm.Save();
59 ············pm.Dispose();
60 ········}
61
62
63 ········private void AddRange()
64 ········{
65 ············ArrayList l = new ArrayList();
66 ············l.Add(r);
67 ············l.Add(r2);
68 ············m.ReisenAddRange(l);
69 ············Assert.That(GetLoadState(), "Relation not loaded");
70 ············pm.Save();
71 ············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "Wrong state #1");
72 ············pm.MakeAllHollow();
73 ············pm.UnloadCache();
74 ············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "Wrong state #2");
75 ············Assert.That(!GetLoadState(), "Relation should not be loaded");
76 ········}
77
78
79 ········[Test]
80 ········public void TestAddRange()
81 ········{
82 ············AddRange();
83 ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm);
84 ············m = q.ExecuteSingle(true);
85 ············Assert.That(2 ==··m.Reisen.Count, "Count of Reisen wrong");
86 ········}
87
88 ········[Test]
89 ········public void TestBinarySearch()
90 ········{
91 ············AddRange();
92 ············int index = m.ReisenBinarySearch(r);
93 ············// Don't care about the result, the object won't be fount
94 ············Assert.That(GetLoadState(), "Relation not loaded");
95 ········}
96
97 ········[Test]
98 ········public void ReisenCapacity()
99 ········{
100 ············AddRange();
101 ············int result = m.ReisenCapacity;
102 ············Assert.That(GetLoadState(), "Relation not loaded");
103 ········}
104
105 ········[Test]
106 ········public void ReisenGetRange()
107 ········{
108 ············AddRange();
109 ············IList l = m.ReisenGetRange(0, 2);
110 ············Assert.That(GetLoadState(), "Relation not loaded");
111 ············Assert.That(2 ==··l.Count, "Count is wrong");
112 ········}
113
114 ········[Test]
115 ········public void ReisenInsertRange()
116 ········{
117 ············AddRange();
118 ············ArrayList range = new ArrayList();
119 ············range.Add(CreateReise("foo"));
120 ············range.Add(CreateReise("bar"));
121 ············m.ReisenInsertRange(1, range);
122 ············Assert.That(GetLoadState(), "Relation not loaded");
123 ············Assert.That(m.Reisen[1] ==··(Reise)range[0], "Wrong order");
124 ············SaveAndReload();
125 ············Assert.That(4 ==··m.Reisen.Count, "Count of Reisen wrong");
126 ········}
127
128 ········[Test]
129 ········public void ReisenLastIndexOf()
130 ········{
131 ············AddRange();
132 ············int i = m.ReisenLastIndexOf(r, 1, 2);
133 ············Assert.That(GetLoadState(), "Relation not loaded");
134 ········}
135
136 ········[Test]
137 ········public void ReisenRemoveRange()
138 ········{
139 ············AddRange();
140 ············m.ReisenRemoveRange(0, 1);
141 ············Assert.That(GetLoadState(), "Relation not loaded");
142 ············Assert.That(1 ==··m.Reisen.Count, "Count of Reisen wrong #1");
143 ············SaveAndReload();
144 ············Assert.That(1 ==··m.Reisen.Count, "Count of Reisen wrong #2");
145 ········}
146
147 ········[Test]
148 ········public void ReisenReverse()
149 ········{
150 ············AddRange();
151 ············m.ReisenReverse();
152 ············Assert.That(GetLoadState(), "Relation not loaded");
153 ········}
154
155 ········//[Test]
156 ········//public void ReisenSetRange()
157 ········//{
158 ········//····AddRange();
159 ········//····ArrayList l = new ArrayList();
160 ········//····l.Add(CreateReise("foo"));
161 ········//····l.Add(CreateReise("bar"));
162 ········//····m.ReisenSetRange(0, l);
163 ····//Assert.That(GetLoadState(), "Relation not loaded");
164 ····//Assert.That("foo" ==··(m.Reisen[0] as Reise).Zweck, "Falsche Reise #1");
165 ····//Assert.That("bar" ==··(m.Reisen[1] as Reise).Zweck, "Falsche Reise #2");
166 ····//····//····SaveAndReload();
167 ····//Assert.That(2 ==··m.Reisen.Count, "Count of Reisen wrong");
168 ····//····//····if (((Reise)m.Reisen[0]).NDOObjectId.Id[0] is Int32)
169 ····//····//····{
170 ····//····//········m.ReisenSort();
171 ····//····Assert.That("bar" ==··(m.Reisen[0] as Reise).Zweck, "Falsche Reise #3");
172 ····//····Assert.That("foo" ==··(m.Reisen[1] as Reise).Zweck, "Falsche Reise #4");
173 ········//····}
174 ········//}
175
176 ········[Test]
177 ········public void ReisenSort()
178 ········{
179 ············AddRange();
180 ············m.ReisenSort();
181 ············Assert.That(GetLoadState(), "Relation not loaded");
182 ········}
183
184 ········[Test]
185 ········public void ReisenToArray()
186 ········{
187 ············AddRange();
188 ············object o = m.ReisenToArray(typeof(Reise));
189 ············Assert.That(GetLoadState(), "Relation not loaded");
190 ········}
191
192 ········//[Test]
193 ········//public void ReisenTrimToSize()
194 ········//{
195 ········//····AddRange();
196 ········//····m.ReisenTrimToSize();
197 ········//Assert.That(GetLoadState(), "Relation not loaded");
198 ········//}
199 ········
200 ········[Test]
201 ········public void ReisenCount()
202 ········{
203 ············AddRange();
204 ············int x = m.ReisenCount;
205 ············Assert.That(GetLoadState(), "Relation not loaded");
206 ········}
207
208 ········[Test]
209 ········public void ReisenContains()
210 ········{
211 ············AddRange();
212 ············bool test = m.ReisenContains(r);
213 ············Assert.That(GetLoadState(), "Relation not loaded");
214 ········}
215
216 ········[Test]
217 ········public void ReisenCopyTo()
218 ········{
219 ············AddRange();
220 ············Reise[] arr = m.ReisenCopyTo;
221 ············Assert.That(GetLoadState(), "Relation not loaded");
222 ············Assert.That((arr[0].Zweck == r.Zweck || arr[0].Zweck == r2.Zweck) && (arr[1].Zweck == r.Zweck || arr[1].Zweck == r2.Zweck), "Reisen not found");
223 ········}
224
225 ········[Test]
226 ········public void ReisenEquals()
227 ········{
228 ············Object o = r;
229 ············AddRange();
230 ············bool dummy = m.ReisenEquals(o);
231 ············Assert.That(GetLoadState(), "Relation not loaded");
232 ········}
233
234 ········[Test]
235 ········public void ReisenEnumerator()
236 ········{
237 ············AddRange();
238 ············IEnumerator ie = m.ReisenEnumerator;
239 ············Assert.That(GetLoadState(), "Relation not loaded");
240 ············ie.MoveNext();
241 ············Assert.That(((Reise)ie.Current).Zweck != r.Zweck ||··((Reise)ie.Current).Zweck != r2.Zweck, "Reise wrong #1");
242 ············ie.MoveNext();
243 ············Assert.That(((Reise)ie.Current).Zweck != r.Zweck ||··((Reise)ie.Current).Zweck != r2.Zweck, "Reise wrong #2");
244 ········}
245
246 ········[Test]
247 ········public void ReisenHashCode()
248 ········{
249 ············AddRange();
250 ············int result = m.ReisenHashCode();
251 ············Assert.That(GetLoadState(), "Relation not loaded");
252 ········}
253
254 ········[Test]
255 ········public void ReisenGetType()
256 ········{
257 ············AddRange();
258 ············Type t = m.ReisenGetType();
259 ············Assert.That(GetLoadState(), "Relation not loaded");
260 ········}
261
262 ········[Test]
263 ········public void ReisenIndexOf()
264 ········{
265 ············AddRange();
266 ············int result = m.ReisenIndexOf(r);
267 ············Assert.That(GetLoadState(), "Relation not loaded");
268 ········}
269
270 ········//[Test]
271 ········//public void ReisenIsFixedSize()
272 ········//{
273 ········//····AddRange();
274 ········//····bool result = m.ReisenIsFixedSize;
275 //····Assert.That(GetLoadState(), "Relation not loaded");
276 ········//}
277
278 ········//[Test]
279 ········//public void ReisenIsReadOnly()
280 ········//{
281 ········//····AddRange();
282 ········//····bool result = m.ReisenIsReadOnly;
283 //·· Assert.That(GetLoadState(), "Relation not loaded");
284 ········//}
285
286
287 ········//[Test]
288 ········//public void ReisenIsSynchronized()
289 ········//{
290 ········//····AddRange();
291 ········//····bool b = m.ReisenIsSynchronized;
292 //····Assert.That(GetLoadState(), "Relation not loaded");
293 ········//}
294
295
296 ········//[Test]
297 ········//public void ReisenSyncRoot()
298 ········//{
299 ········//····AddRange();
300 ········//····object o = m.ReisenSyncRoot;
301 //····Assert.That(GetLoadState(), "Relation not loaded");
302 ········//}
303
304 ········[Test]
305 ········public void ReisenRemoveAt()
306 ········{
307 ············AddRange();
308 ············m.ReisenRemoveAt(1);
309 ············string zweck = ((Reise)m.Reisen[0]).Zweck;
310 ············Assert.That(GetLoadState(), "Relation not loaded");
311 ············SaveAndReload();
312 ············Assert.That(1 ==··m.Reisen.Count, "Wrong count");
313 ············Assert.That(zweck ==··((Reise)m.Reisen[0]).Zweck, "Reise wrong");
314 ········}
315
316 ········[Test]
317 ········public void ReisenToString()
318 ········{
319 ············AddRange();
320 ············string s = m.ReisenToString;
321 ············Assert.That(GetLoadState(), "Relation not loaded");
322 ········}
323
324 ········private Mitarbeiter CreateMitarbeiter(string vorname, string nachname)
325 ········{
326 ············Mitarbeiter m = new Mitarbeiter();
327 ············m.Vorname = vorname;
328 ············m.Nachname = nachname;
329 ············return m;
330 ········}
331
332 ········private Reise CreateReise(string zweck)
333 ········{
334 ············Reise r = new Reise();
335 ············r.Zweck = zweck;
336 ············return r;
337 ········}
338
339 ········private bool GetLoadState()
340 ········{
341 ············NDO.Mapping.Relation r = pm.NDOMapping.FindClass(typeof(Mitarbeiter)).FindRelation("dieReisen");
342 ············FieldInfo fi = typeof(NDO.Mapping.Relation).GetField("Ordinal", BindingFlags.NonPublic | BindingFlags.Instance);
343 ············Assert.That(fi != null);
344 ············object o = fi.GetValue(r);
345 ············Assert.That(o != null);
346 ············return ((IPersistenceCapable)m).NDOGetLoadState((int)o);
347 ········}
348
349 ········private void SaveAndReload()
350 ········{
351 ············pm.Save();
352 ············pm.UnloadCache();
353 ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm);
354 ············m = (Mitarbeiter) q.ExecuteSingle(true);
355 ········}
356
357
358 ····}
359 }
360