Datei: IntegrationTests/IntegrationTests/DataTypeTest.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.Reflection;
25 using System.Collections;
26 using DataTypeTestClasses;
27 using NDO;
28 using NDO.Mapping;
29 using NUnit.Framework;
30 using NDO.Query;
31 using System.Linq;
32
33 namespace NdoUnitTests
34 {
35 ····[TestFixture]
36 public class DataTypeTest
37 ····{
38 ········[SetUp]
39 ········public void Setup()
40 ········{
41 ········}
42
43 ········[TearDown]
44 ········public void TearDown()
45 ········{
46 ············var pm = PmFactory.NewPersistenceManager();
47
48 ············IList l = pm.GetClassExtent(typeof(DataContainer), true);
49 ············if (l.Count > 0)
50 ············{
51 ················pm.Delete( l );
52 ················pm.Save();
53 ············}
54 ············l = pm.GetClassExtent( typeof( DataContainerDerived ), true );
55 ············if (l.Count > 0)
56 ············{
57 ················pm.Delete( l );
58 ················pm.Save();
59 ············}
60 ············l = pm.GetClassExtent( typeof( VtAndEtContainer ), true );
61 ············if (l.Count > 0)
62 ············{
63 ················pm.Delete( l );
64 ················pm.Save();
65 ············}
66 ············l = pm.GetClassExtent( typeof( VtAndEtContainerDerived ), true );
67 ············if (l.Count > 0)
68 ············{
69 ················pm.Delete( l );
70 ················pm.Save();
71 ············}
72 ············l = pm.GetClassExtent( typeof( NullableDataContainer ), true );
73 ············if (l.Count > 0)
74 ············{
75 ················pm.Delete( l );
76 ················pm.Save();
77 ············}
78 ············l = pm.GetClassExtent( typeof( NullableDataContainerDerived ), true );
79 ············if (l.Count > 0)
80 ············{
81 ················pm.Delete( l );
82 ················pm.Save();
83 ············}
84
85 ············pm.Close();
86 ········}
87
88 ········[Test]
89 ········public void TestDataContainer()
90 ········{
91 ············DataContainer dc = new DataContainer();
92
93 ············dc.Init();
94
95 ············var pm = PmFactory.NewPersistenceManager();
96
97 ············pm.MakePersistent(dc);
98 ············pm.Save();
99 ············pm.UnloadCache();
100 ············IList l = pm.GetClassExtent(typeof(DataContainer));
101 ············Assert.That(1 ==··l.Count, "Ein Objekt sollte in der Liste sein");
102 ············dc = (DataContainer) l[0];
103 ············AssertDataContainer(dc);
104 ········}
105
106 ········[Test]
107 ········public void TestNullableDataContainer()
108 ········{
109 ············NullableDataContainer ndc = new NullableDataContainer();
110 ············ndc.Init();
111
112 ············var pm = PmFactory.NewPersistenceManager();
113 ············pm.MakePersistent(ndc);
114 ············pm.Save();
115 ············pm.UnloadCache();
116 ············ndc = new NDOQuery<NullableDataContainer>(pm, null, false).ExecuteSingle(true);
117 ············AssertNullableDataContainer(ndc);
118 ········}
119
120
121 ········[Test]
122 ········public void TestNullableDataContainerDerived()
123 ········{
124 ············NullableDataContainerDerived ndc = new NullableDataContainerDerived();
125 ············ndc.Init();
126
127 ············var pm = PmFactory.NewPersistenceManager();
128 ············pm.MakePersistent(ndc);
129 ············pm.Save();
130 ············pm.UnloadCache();
131 ············ndc = new NDOQuery<NullableDataContainerDerived>(pm, null, false).ExecuteSingle(true);
132 ············AssertNullableDataContainer(ndc);
133 ········}
134
135 ········private bool FieldWithNameExists(Class cl, string name)
136 ········{
137 ············foreach(Field field in cl.Fields)
138 ················if (field.Name.IndexOf(name) > -1)
139 ····················return true;
140 ············return false;
141 ········}
142
143 ········//public void TestDataContainerEvent()
144 ········//{
145 ········//····Type t = typeof(DataContainer.QueryHelper);
146
147 ········//····Class cl = pm.NDOMapping.FindClass(typeof(DataContainer));
148 ········//····Assert.That(cl.FindField("TestEvent") == null, "Events should not be mapped");
149
150 ········//····Assert.That(t.GetMember("int16Var" != null, BindingFlags.Instance), "Variables should appear in qh");
151 ········//····PropertyInfo pi = t.GetProperty("TestEvent");
152 ········//····Assert.That(pi == null, "Events should not appear in qh");
153
154 ········//····//----
155 ········//····t = typeof(DataContainerDerived.QueryHelper);
156
157 ········//····cl = pm.NDOMapping.FindClass(typeof(DataContainerDerived));
158 ········//····Assert.That(!FieldWithNameExists(cl, "TestEvent"), "Events should not be mapped");
159
160 ········//····Assert.That(t.GetMember("int16Var" != null, BindingFlags.Instance), "Variables should appear in qh");
161 ········//····pi = t.GetProperty("TestEvent");
162 ········//····Assert.That(pi == null, "Events should not appear in qh");
163
164 ········//····//----
165 ········//····t = typeof(VtAndEtContainer.QueryHelper);
166
167 ········//····cl = pm.NDOMapping.FindClass(typeof(VtAndEtContainer));
168 ········//····Assert.That(!FieldWithNameExists(cl, "TestEvent"), "Events should not be mapped");
169
170 ········//····Assert.That(t.GetMember("int16Var" != null, BindingFlags.Instance), "Variables should appear in qh");
171 ········//····pi = t.GetProperty("TestEvent");
172 ········//····Assert.That(pi == null, "Events should not appear in qh");
173
174 ········//····//----
175 ········//····t = typeof(VtAndEtContainerDerived.QueryHelper);
176
177 ········//····cl = pm.NDOMapping.FindClass(typeof(VtAndEtContainerDerived));
178 ········//····Assert.That(!FieldWithNameExists(cl, "TestEvent"), "Events should not be mapped");
179
180 ········//····Assert.That(t.GetMember("int16Var" != null, BindingFlags.Instance), "Variables should appear in qh");
181 ········//····pi = t.GetProperty("TestEvent");
182 ········//····Assert.That(pi == null, "Events should not appear in qh");
183
184 ········//}
185
186 ········[Test]
187 ········public void TestDataContainerDerived()
188 ········{············
189 ············DataContainerDerived dcd = new DataContainerDerived();
190 ············dcd.Init();
191 ············var pm = PmFactory.NewPersistenceManager();
192 ············pm.MakePersistent(dcd);
193 ············pm.Save();
194 ············pm.UnloadCache();
195 ············IList l = pm.GetClassExtent(typeof(DataContainerDerived));
196 ············Assert.That(1 ==··l.Count, "Ein Objekt sollte in der Liste sein");
197 ············dcd = (DataContainerDerived) l[0];
198 ············AssertDataContainer(dcd);
199 ········}
200
201 ········bool CheckDouble( double d1, double d2 )
202 ········{
203 ············double eps = Math.Abs(d1 * 1E-6);
204 ············return (d1 - eps) <= d2 && d2 <= (d1 + eps);
205 ········}
206
207 ········bool CheckFloat( float d1, float d2 )
208 ········{
209 ············double eps = Math.Abs( d1 * 1E-6 );
210 ············return (d1 - eps) <= d2 && d2 <= (d1 + eps);
211 ········}
212
213 ········void AssertDataContainer(DataContainer dc)
214 ········{
215 ············Assert.That(true ==··dc.BoolVar, "BoolVar falsc h");
216 ············Assert.That(127 ==··dc.ByteVar, "ByteVar falsch");
217 ············Assert.That("Test" ==··dc.StringVar, "StringVar falsch");
218 ············Assert.That(DateTime.Now.Date ==··dc.DateTimeVar.Date, "DateTimeVar falsch");
219 ············Assert.That(new Guid("12341234-1234-1234-1234-123412341234") ==··dc.GuidVar, "GuidVar falsch");
220 ············Assert.That(1231.12m ==··dc.DecVar, "DecVar falsch");
221 ············Assert.That(int.MaxValue ==··dc.Int32Var, "Int32Var falsch");
222 ············Assert.That((uint) int.MaxValue ==··dc.Uint32Var, "UInt32Var falsch");
223 #if SQLITE
224 ············Assert.That(CheckDouble(1E28, dc.DoubleVar), "DoubleVar falsch");
225 ············Assert.That(CheckFloat(1E14F, dc.FloatVar), "FloatVar falsch");
226 #else
227 ············Assert.That(1E28 ==··dc.DoubleVar, "DoubleVar falsch");
228 ············Assert.That(1E14F ==··dc.FloatVar, "FloatVar falsch");
229 #endif
230 ············Assert.That(0x1ffffffff ==··dc.Int64Var, "Int64Var falsch");
231 ············Assert.That(short.MaxValue ==··dc.Int16Var, "Int16Var falsch");
232 ············Assert.That((ushort) short.MaxValue ==··dc.Uint16Var, "UInt16Var falsch");
233 ············Assert.That(0x1ffffffff ==··dc.Uint64Var, "UInt64Var falsch");
234 ············Assert.That(EnumType.drei ==··dc.EnumVar, "EnumType falsch");
235 ············Assert.That(Guid.Empty ==··dc.EmptyGuidVar, "Empty Guid falsch");
236 ············Assert.That(DateTime.MinValue ==··dc.EmptyDateTimeVar, "Empty DateTime falsch");
237 ············Assert.That(dc.NullString == null, "Empty String falsch");
238 ········}
239
240
241 ········void AssertNullableDataContainer(NullableDataContainer dc)
242 ········{
243 ············Assert.That(true ==··dc.BoolVar, "BoolVar falsch");
244 ············Assert.That(127 ==··dc.ByteVar, "ByteVar falsch");
245 ············Assert.That(DateTime.Now.Date ==··dc.DateTimeVar.Value.Date, "DateTimeVar falsch");
246 ············Assert.That(new Guid("12341234-1234-1234-1234-123412341234") ==··dc.GuidVar, "GuidVar falsch");
247 ············Assert.That(1231.12m ==··dc.DecVar, "DecVar falsch");
248 ············Assert.That(int.MaxValue ==··dc.Int32Var, "Int32Var falsch");
249 ············Assert.That((uint)int.MaxValue ==··dc.Uint32Var, "UInt32Var falsch");
250 #if SQLITE
251 ············Assert.That(CheckDouble(1E28, dc.DoubleVar.Value), "DoubleVar falsch");
252 ············Assert.That(CheckFloat(1E14F, dc.FloatVar.Value), "FloatVar falsch");
253 #else
254 ············Assert.That(1E28 ==··dc.DoubleVar.Value, "DoubleVar falsch");
255 ············Assert.That(1E14F ==··dc.FloatVar.Value, "FloatVar falsch");
256 #endif
257 ············Assert.That(0x1ffffffff ==··dc.Int64Var, "Int64Var falsch");
258 ············Assert.That(short.MaxValue ==··dc.Int16Var, "Int16Var falsch");
259 ············Assert.That((ushort)short.MaxValue ==··dc.Uint16Var, "UInt16Var falsch");
260 ············Assert.That(0x1ffffffff ==··dc.Uint64Var, "UInt64Var falsch");
261 ············Assert.That(EnumType.drei ==··dc.EnumVar, "EnumType falsch");
262
263 #if !ACCESS··// Access initializes bool vars always with False
264 ············Assert.That(!dc.BoolEmptyVar.HasValue, "BoolEmptyVar falsch");
265 #endif
266 ············Assert.That(!dc.ByteEmptyVar.HasValue, "ByteVar falsch");
267 ············Assert.That(!dc.DateTimeEmptyVar.HasValue, "DateTimeVar falsch");
268 ············Assert.That(!dc.GuidEmptyVar.HasValue, "GuidVar falsch");
269 ············Assert.That(!dc.DecEmptyVar.HasValue, "DecVar falsch");
270 ············Assert.That(!dc.Int32EmptyVar.HasValue, "Int32Var falsch");
271 ············Assert.That(!dc.Uint32EmptyVar.HasValue, "UInt32Var falsch");
272 ············Assert.That(!dc.DoubleEmptyVar.HasValue, "DoubleVar falsch");
273 ············Assert.That(!dc.FloatEmptyVar.HasValue, "FloatVar falsch");
274 ············Assert.That(!dc.Int64EmptyVar.HasValue, "Int64Var falsch");
275 ············Assert.That(!dc.Int16EmptyVar.HasValue, "Int16Var falsch");
276 ············Assert.That(!dc.Uint16EmptyVar.HasValue, "UInt16Var falsch");
277 ············Assert.That(!dc.Uint64EmptyVar.HasValue, "UInt64Var falsch");
278 ············Assert.That(!dc.EnumEmptyVar.HasValue, "EnumType falsch");
279
280 ········}
281
282 ········[Test]
283 ········public void QueryWithEmptyGuidParameterSearchesForNull()
284 ········{
285 ············var pm = PmFactory.NewPersistenceManager();
286
287 ············DataContainer dc = new DataContainer();
288 ············dc.Init();
289 ············dc.GuidVar = Guid.Empty;
290 ············pm.MakePersistent( dc );
291 ············pm.Save();
292 ············pm.UnloadCache();
293
294 ············var q = new NDOQuery<DataContainer>(pm, "guidVar = {0}");
295 ············q.Parameters.Add( Guid.Empty );
296 ············var list = q.Execute();
297 ············Assert.That(Guid.Empty ==··list.First().GuidVar );
298 ········}
299
300 ········[Test]
301 ········public void QueryWithDateTimeMinValueParameterSearchesForNull()
302 ········{
303 ············var pm = PmFactory.NewPersistenceManager();
304
305 ············DataContainer dc = new DataContainer();
306
307 ············dc.Init();
308 ············dc.DateTimeVar = DateTime.MinValue;
309 ············pm.MakePersistent( dc );
310 ············pm.Save();
311 ············pm.UnloadCache();
312
313 ············var q = new NDOQuery<DataContainer>(pm, "dateTimeVar = {0}");
314 ············q.Parameters.Add( DateTime.MinValue );
315 ············var list = q.Execute();
316 ············Assert.That(DateTime.MinValue ==··list.First().DateTimeVar );
317 ········}
318
319
320 ········[Test]
321 ········public void ParametersTest()
322 ········{
323 ············var pm = PmFactory.NewPersistenceManager();
324
325 ············DataContainer dc = new DataContainer();
326 ············dc.Init();
327 ············pm.MakePersistent(dc);
328 ············pm.Save();
329 ············IQuery q = new NDOQuery<DataContainer>(pm, "boolVar" + " = " + "{0}");
330 #if !ORACLE
331 ············q.Parameters.Add(true);
332 #else
333 ············q.Parameters.Add(1);
334 #endif
335 ············q.ExecuteSingle(true);··// If something goes wrong, an Exception will be thrown.
336 ············
337 ············q = new NDOQuery<DataContainer>(pm, "byteVar" + " = " + "{0}");
338 ············q.Parameters.Add((byte)127);
339 ············q.ExecuteSingle(true);··// If something goes wrong, an Exception will be thrown.
340
341 ············q = new NDOQuery<DataContainer>(pm, "dateTimeVar" + " <= " + "{0}");
342 ············q.Parameters.Add(DateTime.Now);
343 ············q.ExecuteSingle(true);··// If something goes wrong, an Exception will be thrown.
344
345 ············q = new NDOQuery<DataContainer>(pm, "guidVar" + " = " + "{0}");
346 ············q.Parameters.Add(new Guid("12341234-1234-1234-1234-123412341234"));
347 ············q.ExecuteSingle(true);··// If something goes wrong, an Exception will be thrown.
348
349 ············q = new NDOQuery<DataContainer>(pm, "decVar" + " = " + "{0}");
350 ············q.Parameters.Add(1231.12m);
351 ············q.ExecuteSingle(true);··// If something goes wrong, an Exception will be thrown.
352
353 ············q = new NDOQuery<DataContainer>(pm, "doubleVar" + " = " + "{0}");
354 ············q.Parameters.Add(1E28);
355 ············q.ExecuteSingle(true);··// If something goes wrong, an Exception will be thrown.
356
357 ············q = new NDOQuery<DataContainer>(pm, "enumVar" + " = " + "{0}");
358 ············q.Parameters.Add(EnumType.drei);
359 ············q.ExecuteSingle(true);··// If something goes wrong, an Exception will be thrown.
360
361 #if !MYSQL
362 ············q = new NDOQuery<DataContainer>(pm, "floatVar" + " = " + "{0}");
363 ············q.Parameters.Add(1E14F);
364 ············q.ExecuteSingle(true);··// If something goes wrong, an Exception will be thrown.
365 #endif
366 ············q = new NDOQuery<DataContainer>(pm, "int16Var" + " = " + "{0}");
367 ············q.Parameters.Add(short.MaxValue);
368 ············q.ExecuteSingle(true);··// If something goes wrong, an Exception will be thrown.
369
370 ············q = new NDOQuery<DataContainer>(pm, "int32Var" + " = " + "{0}");
371 ············q.Parameters.Add(int.MaxValue);
372 ············q.ExecuteSingle(true);··// If something goes wrong, an Exception will be thrown.
373
374 ············q = new NDOQuery<DataContainer>(pm, "int64Var" + " = " + "{0}");
375 ············q.Parameters.Add(0x1ffffffff);
376 ············q.ExecuteSingle(true);··// If something goes wrong, an Exception will be thrown.
377
378 ············q = new NDOQuery<DataContainer>(pm, "stringVar" + " = " + "{0}");
379 ············q.Parameters.Add("Test");
380 ············q.ExecuteSingle(true);··// If something goes wrong, an Exception will be thrown.
381
382 ············q = new NDOQuery<DataContainer>(pm, "uint16Var" + " = " + "{0}");
383 ············q.Parameters.Add((ushort) short.MaxValue);
384 ············q.ExecuteSingle(true);··// If something goes wrong, an Exception will be thrown.
385
386 ············q = new NDOQuery<DataContainer>(pm, "uint32Var" + " = " + "{0}");
387 ············q.Parameters.Add((uint) int.MaxValue);
388 ············q.ExecuteSingle(true);··// If something goes wrong, an Exception will be thrown.
389
390 ············q = new NDOQuery<DataContainer>(pm, "uint64Var" + " = " + "{0}");
391 ············q.Parameters.Add(0x1ffffffff);
392 ············dc = (DataContainer) q.ExecuteSingle(true);··// If something goes wrong, an Exception will be thrown.
393
394 ············dc.StringVar = "";
395 ············pm.Save();
396
397 #if ORACLE
398 ············q = new NDOQuery<DataContainer>(pm, "stringVar" + Query.Op.IsNull);
399 ············q.ExecuteSingle(true);··// If something goes wrong, an Exception will be thrown.
400 #else
401 ············q = new NDOQuery<DataContainer>(pm, "stringVar" + " = " + "{0}");
402 ············q.Parameters.Add("");
403 ············q.ExecuteSingle(true);··// If something goes wrong, an Exception will be thrown.
404 #endif
405
406 ········}
407
408
409 #if nix
410 ········[Test]
411 ········public void TestQueryHelpers()
412 ········{············
413 ············Assert.That("propValType.ByteVar" ==··"propValType.ByteVar", "ByteVar falsch #1");
414 ············Assert.That("propValType.BoolVar" ==·· "propValType.BoolVar", "BoolVar falsch #1");
415 ············Assert.That("propValType.DecVar" ==··"propValType.DecVar", "DecVar falsch #1");
416 ············Assert.That("propValType.DateTimeVar" ==··"propValType.DateTimeVar", "DateTimeVar falsch #1");
417 ············Assert.That("propValType.DoubleVar" ==··"propValType.DoubleVar", "DoubleVar falsch #1");
418 ············Assert.That("propValType.FloatVar" ==··"propValType.FloatVar", "FloatVar falsch #1");
419 ············Assert.That("propValType.GuidVar" ==··"propValType.GuidVar", "GuidVar falsch #1");
420 ············Assert.That("propValType.Int16Var" ==··"propValType.Int16Var", "Int16Var falsch #1");
421 ············Assert.That("propValType.Int32Var" ==··"propValType.Int32Var", "Int32Var falsch #1");
422 ············Assert.That("propValType.Int64Var" ==··"propValType.Int64Var", "Int64Var falsch #1");
423 ············Assert.That("propValType.StringVar" ==··"propValType.StringVar", "StringVar falsch #1");
424 ············Assert.That("propValType.Uint16Var" ==··"propValType.Uint16Var", "Uint16Var falsch #1");
425 ············Assert.That("propValType.Uint32Var" ==··"propValType.Uint32Var", "Uint32Var falsch #1");
426 ············Assert.That("propValType.Uint64Var" ==··"propValType.Uint64Var", "Uint64Var falsch #1");
427 ············Assert.That("propValType.EnumVar" ==··"propValType.EnumVar", "EnumVar falsch #1");
428
429 ············Assert.That("pubValType.ByteVar" ==··"pubValType.ByteVar", "ByteVar falsch #2");
430 ············Assert.That("pubValType.BoolVar" ==·· "pubValType.BoolVar", "BoolVar falsch #2");
431 ············Assert.That("pubValType.DecVar" ==··"pubValType.DecVar", "DecVar falsch #2");
432 ············Assert.That("pubValType.DateTimeVar" ==··"pubValType.DateTimeVar", "DateTimeVar falsch #2");
433 ············Assert.That("pubValType.DoubleVar" ==··"pubValType.DoubleVar", "DoubleVar falsch #2");
434 ············Assert.That("pubValType.FloatVar" ==··"pubValType.FloatVar", "FloatVar falsch #2");
435 ············Assert.That("pubValType.GuidVar" ==··"pubValType.GuidVar", "GuidVar falsch #2");
436 ············Assert.That("pubValType.Int16Var" ==··"pubValType.Int16Var", "Int16Var falsch #2");
437 ············Assert.That("pubValType.Int32Var" ==··"pubValType.Int32Var", "Int32Var falsch #2");
438 ············Assert.That("pubValType.Int64Var" ==··"pubValType.Int64Var", "Int64Var falsch #2");
439 ············Assert.That("pubValType.StringVar" ==··"pubValType.StringVar", "StringVar falsch #2");
440 ············Assert.That("pubValType.Uint16Var" ==··"pubValType.Uint16Var", "Uint16Var falsch #2");
441 ············Assert.That("pubValType.Uint32Var" ==··"pubValType.Uint32Var", "Uint32Var falsch #2");
442 ············Assert.That("pubValType.Uint64Var" ==··"pubValType.Uint64Var", "Uint64Var falsch #2");
443 ············Assert.That("pubValType.EnumVar" ==··"pubValType.EnumVar", "EnumVar falsch #2");
444
445 ············Assert.That("embeddedType.byteVar" ==··"embeddedType.byteVar", "ByteVar falsch #3");
446 ············Assert.That("embeddedType.boolVar" ==·· "embeddedType.boolVar", "BoolVar falsch #3");
447 ············Assert.That("embeddedType.decVar" ==··"embeddedType.decVar", "DecVar falsch #3");
448 ············Assert.That("embeddedType.dateTimeVar" ==··"embeddedType.dateTimeVar", "DateTimeVar falsch #3");
449 ············Assert.That("embeddedType.doubleVar" ==··"embeddedType.doubleVar", "DoubleVar falsch #3");
450 ············Assert.That("embeddedType.floatVar" ==··"embeddedType.floatVar", "FloatVar falsch #3");
451 ············Assert.That("embeddedType.guidVar" ==··"embeddedType.guidVar", "GuidVar falsch #3");
452 ············Assert.That("embeddedType.int16Var" ==··"embeddedType.int16Var", "Int16Var falsch #3");
453 ············Assert.That("embeddedType.int32Var" ==··"embeddedType.int32Var", "Int32Var falsch #3");
454 ············Assert.That("embeddedType.int64Var" ==··"embeddedType.int64Var", "Int64Var falsch #3");
455 ············Assert.That("embeddedType.stringVar" ==··"embeddedType.stringVar", "StringVar falsch #3");
456 ············Assert.That("embeddedType.uint16Var" ==··"embeddedType.uint16Var", "Uint16Var falsch #3");
457 ············Assert.That("embeddedType.uint32Var" ==··"embeddedType.uint32Var", "Uint32Var falsch #3");
458 ············Assert.That("embeddedType.uint64Var" ==··"embeddedType.uint64Var", "Uint64Var falsch #3");
459 ············Assert.That("embeddedType.enumVar" ==··"embeddedType.enumVar", "Uint64Var falsch #3");
460
461 ············VtAndEtContainerDerived.QueryHelper "" = new VtAndEtContainerDerived.QueryHelper();
462 ············
463 ············Assert.That("propValType.ByteVar" ==··".propValType.ByteVar", "ByteVar falsch #1");
464 ············Assert.That("propValType.BoolVar" ==·· ".propValType.BoolVar", "BoolVar falsch #1");
465 ············Assert.That("propValType.DecVar" ==··".propValType.DecVar", "DecVar falsch #1");
466 ············Assert.That("propValType.DateTimeVar" ==··".propValType.DateTimeVar", "DateTimeVar falsch #1");
467 ············Assert.That("propValType.DoubleVar" ==··".propValType.DoubleVar", "DoubleVar falsch #1");
468 ············Assert.That("propValType.FloatVar" ==··".propValType.FloatVar", "FloatVar falsch #1");
469 ············Assert.That("propValType.GuidVar" ==··".propValType.GuidVar", "GuidVar falsch #1");
470 ············Assert.That("propValType.Int16Var" ==··".propValType.Int16Var", "Int16Var falsch #1");
471 ············Assert.That("propValType.Int32Var" ==··".propValType.Int32Var", "Int32Var falsch #1");
472 ············Assert.That("propValType.Int64Var" ==··".propValType.Int64Var", "Int64Var falsch #1");
473 ············Assert.That("propValType.StringVar" ==··".propValType.StringVar", "StringVar falsch #1");
474 ············Assert.That("propValType.Uint16Var" ==··".propValType.Uint16Var", "Uint16Var falsch #1");
475 ············Assert.That("propValType.Uint32Var" ==··".propValType.Uint32Var", "Uint32Var falsch #1");
476 ············Assert.That("propValType.Uint64Var" ==··".propValType.Uint64Var", "Uint64Var falsch #1");
477 ············Assert.That("propValType.EnumVar" ==··".propValType.EnumVar", "EnumVar falsch #1");
478
479 ············Assert.That("pubValType.ByteVar" ==··".pubValType.ByteVar", "ByteVar falsch #2");
480 ············Assert.That("pubValType.BoolVar" ==·· ".pubValType.BoolVar", "BoolVar falsch #2");
481 ············Assert.That("pubValType.DecVar" ==··".pubValType.DecVar", "DecVar falsch #2");
482 ············Assert.That("pubValType.DateTimeVar" ==··".pubValType.DateTimeVar", "DateTimeVar falsch #2");
483 ············Assert.That("pubValType.DoubleVar" ==··".pubValType.DoubleVar", "DoubleVar falsch #2");
484 ············Assert.That("pubValType.FloatVar" ==··".pubValType.FloatVar", "FloatVar falsch #2");
485 ············Assert.That("pubValType.GuidVar" ==··".pubValType.GuidVar", "GuidVar falsch #2");
486 ············Assert.That("pubValType.Int16Var" ==··".pubValType.Int16Var", "Int16Var falsch #2");
487 ············Assert.That("pubValType.Int32Var" ==··".pubValType.Int32Var", "Int32Var falsch #2");
488 ············Assert.That("pubValType.Int64Var" ==··".pubValType.Int64Var", "Int64Var falsch #2");
489 ············Assert.That("pubValType.StringVar" ==··".pubValType.StringVar", "StringVar falsch #2");
490 ············Assert.That("pubValType.Uint16Var" ==··".pubValType.Uint16Var", "Uint16Var falsch #2");
491 ············Assert.That("pubValType.Uint32Var" ==··".pubValType.Uint32Var", "Uint32Var falsch #2");
492 ············Assert.That("pubValType.Uint64Var" ==··".pubValType.Uint64Var", "Uint64Var falsch #2");
493 ············Assert.That("pubValType.EnumVar" ==··".pubValType.EnumVar", "EnumVar falsch #2");
494
495 ············Assert.That("embeddedType.byteVar" ==··".embeddedType.byteVar", "ByteVar falsch #3");
496 ············Assert.That("embeddedType.boolVar" ==·· ".embeddedType.boolVar", "BoolVar falsch #3");
497 ············Assert.That("embeddedType.decVar" ==··".embeddedType.decVar", "DecVar falsch #3");
498 ············Assert.That("embeddedType.dateTimeVar" ==··".embeddedType.dateTimeVar", "DateTimeVar falsch #3");
499 ············Assert.That("embeddedType.doubleVar" ==··".embeddedType.doubleVar", "DoubleVar falsch #3");
500 ············Assert.That("embeddedType.floatVar" ==··".embeddedType.floatVar", "FloatVar falsch #3");
501 ············Assert.That("embeddedType.guidVar" ==··".embeddedType.guidVar", "GuidVar falsch #3");
502 ············Assert.That("embeddedType.int16Var" ==··".embeddedType.int16Var", "Int16Var falsch #3");
503 ············Assert.That("embeddedType.int32Var" ==··".embeddedType.int32Var", "Int32Var falsch #3");
504 ············Assert.That("embeddedType.int64Var" ==··".embeddedType.int64Var", "Int64Var falsch #3");
505 ············Assert.That("embeddedType.stringVar" ==··".embeddedType.stringVar", "StringVar falsch #3");
506 ············Assert.That("embeddedType.uint16Var" ==··".embeddedType.uint16Var", "Uint16Var falsch #3");
507 ············Assert.That("embeddedType.uint32Var" ==··".embeddedType.uint32Var", "Uint32Var falsch #3");
508 ············Assert.That("embeddedType.uint64Var" ==··".embeddedType.uint64Var", "Uint64Var falsch #3");
509 ············Assert.That("embeddedType.enumVar" ==··".embeddedType.enumVar", "Uint64Var falsch #3");
510
511 ········}
512 #endif
513
514 ········[Test]
515 ········public void TestPrimitiveTypeMethodCall()
516 ········{
517 ············PrimitiveTypeMethodCaller mc1 = new PrimitiveTypeMethodCaller();
518 ············PrimitiveTypeMethodCaller mc2 = new PrimitiveTypeMethodCaller();
519 ············Assert.That(0 ==··mc1.StringTest(mc2), "Result must be 0 #1");
520 ············Assert.That(0 ==··mc1.DoubleTest(mc2), "Result must be 0 #2");
521 ············Assert.That(0 ==··mc1.DateTimeTest(mc2), "Result must be 0 #3");
522 ············Assert.That(0 ==··mc1.BoolTest(mc2), "Result must be 0 #4");
523 ············Assert.That(0 ==··mc1.IntTest(mc2), "Result must be 0 #5");
524 ········}
525
526 ········[Test]
527 ········public void TestValueTypeAndEmbeddedType()
528 ········{
529 ············var pm = PmFactory.NewPersistenceManager();
530
531 ············Class cl = pm.NDOMapping.FindClass("DataTypeTestClasses.VtAndEtContainer");
532 ············Field f = cl.FindField("embeddedType.doubleVar");
533 ············f.Column.Size = 12;
534 ············f.Column.Precision = 7;
535 ············VtAndEtContainer cont = new VtAndEtContainer();
536 ············cont.Init();
537 ············pm.MakePersistent(cont);
538 ············pm.Save();
539 ············pm.UnloadCache();
540 ············IList l = pm.GetClassExtent(typeof(VtAndEtContainer));
541 ············Assert.That(1 ==··l.Count, "Anzahl Container stimmt nicht");
542 ············cont = (VtAndEtContainer) l[0];
543 ············AssertVtAndEtContainer(cont);········
544 ········}
545
546 ········[Test]
547 ········public void TestValueTypeAndEmbeddedTypeDerived()
548 ········{
549 ············var pm = PmFactory.NewPersistenceManager();
550
551 ············VtAndEtContainerDerived cont = new VtAndEtContainerDerived();
552 ············cont.Init();
553 ············pm.MakePersistent(cont);
554 ············pm.Save();
555 ············pm.UnloadCache();
556 ············IList l = pm.GetClassExtent(typeof(VtAndEtContainerDerived));
557 ············Assert.That(1 ==··l.Count, "Anzahl Container stimmt nicht");
558 ············cont = (VtAndEtContainerDerived) l[0];
559 ············AssertVtAndEtContainer(cont);········
560 ········}
561
562
563 ········void AssertVtAndEtContainer(VtAndEtContainer cont)
564 ········{
565 ············Assert.That(0x55 ==··cont.PropValType.ByteVar, "ByteVar falsch #1");
566 ············Assert.That(true ==·· cont.PropValType.BoolVar, "BoolVar falsch #1");
567 ············Assert.That(12.34m ==··cont.PropValType.DecVar, "DecVar falsch #1");
568 #if !FIREBIRD && !POSTGRE
569 ············Assert.That(new DateTime(2002, 12, 1, 1, 0, 20) == cont.PropValType.DateTimeVar, "DateTimeVar falsch #1");
570 #else
571 ············Assert.That(new DateTime(2002, 12, 1, 0, 0, 0) == cont.PropValType.DateTimeVar, "DateTimeVar falsch #1");
572 #endif
573 #if SQLITE
574 ············Assert.That( CheckDouble( 12345.123456, cont.PropValType.DoubleVar ), "DoubleVar falsch #1" );
575 ············Assert.That( CheckFloat( 12345.1f, cont.PropValType.FloatVar ), "FloatVar falsch #1" );
576 #else
577 ············Assert.That(12345.123456 ==··cont.PropValType.DoubleVar, "DoubleVar falsch #1");
578 ············Assert.That(12345.1f ==··cont.PropValType.FloatVar, "FloatVar falsch #1");
579 #endif
580 ············Assert.That(new Guid("12341234-1234-1234-1234-123412341234") ==··cont.PropValType.GuidVar, "GuidVar falsch #1");
581 ············Assert.That(0x1234 ==··cont.PropValType.Int16Var, "Int16Var falsch #1");
582 ············Assert.That(0x12341234 ==··cont.PropValType.Int32Var, "Int32Var falsch #1");
583 ············Assert.That(0x143214321 ==··cont.PropValType.Int64Var, "Int64Var falsch #1");
584 ············Assert.That("Teststring" ==··cont.PropValType.StringVar, "StringVar falsch #1");
585 ············Assert.That(0xabc ==··cont.PropValType.Uint16Var, "Uint16Var falsch #1");
586 ············Assert.That(0x12341234 ==··cont.PropValType.Uint32Var, "Uint32Var falsch #1");
587 ············Assert.That(0x143214321 ==··cont.PropValType.Uint64Var, "Uint64Var falsch #1");
588 ············Assert.That(EnumType.zwei ==··cont.PropValType.EnumVar, "EnumVar falsch #1");
589 ············Assert.That(Guid.Empty ==··cont.PropValType.EmptyGuidVar, "EmptyGuidVar falsch #1");
590 ············Assert.That(DateTime.MinValue ==··cont.PropValType.EmptyDateTimeVar, "EmptyDateTimeVar falsch #1");
591 ············Assert.That(cont.PropValType.NullString == null, "Empty String falsch #1");
592
593 ············Assert.That(0x55 ==··cont.PubValType.ByteVar, "ByteVar falsch #2");
594 ············Assert.That(true ==·· cont.PubValType.BoolVar, "BoolVar falsch #2");
595 ············Assert.That(12.34m ==··cont.PubValType.DecVar, "DecVar falsch #2");
596 #if !FIREBIRD && !POSTGRE
597 ············Assert.That(new DateTime(2002, 12, 1, 1, 0, 20) == cont.PubValType.DateTimeVar, "DateTimeVar falsch #2");
598 #else
599 ············Assert.That(new DateTime(2002, 12, 1, 0, 0, 0) == cont.PubValType.DateTimeVar, "DateTimeVar falsch #2");
600 #endif
601 #if SQLITE
602 ············Assert.That( CheckDouble( 12345.123456, cont.PropValType.DoubleVar ), "DoubleVar falsch #1" );
603 ············Assert.That( CheckFloat( 12345.1f, cont.PropValType.FloatVar ), "FloatVar falsch #1" );
604 #else
605 ············Assert.That(12345.123456 ==··cont.PubValType.DoubleVar, "DoubleVar falsch #2");
606 ············Assert.That(12345.1f ==··cont.PubValType.FloatVar, "FloatVar falsch #2");
607 #endif
608 ············Assert.That(new Guid("12341234-1234-1234-1234-123412341234") ==··cont.PubValType.GuidVar, "GuidVar falsch #2");
609 ············Assert.That(0x1234 ==··cont.PubValType.Int16Var, "Int16Var falsch #2");
610 ············Assert.That(0x12341234 ==··cont.PubValType.Int32Var, "Int32Var falsch #2");
611 ············Assert.That(0x143214321 ==··cont.PubValType.Int64Var, "Int64Var falsch #2");
612 ············Assert.That("Teststring" ==··cont.PubValType.StringVar, "StringVar falsch #2");
613 ············Assert.That(0xabc ==··cont.PubValType.Uint16Var, "Uint16Var falsch #2");
614 ············Assert.That(0x12341234 ==··cont.PubValType.Uint32Var, "Uint32Var falsch #2");
615 ············Assert.That(0x143214321 ==··cont.PubValType.Uint64Var, "Uint64Var falsch #2");
616 ············Assert.That(EnumType.zwei ==··cont.PubValType.EnumVar, "EnumVar falsch #2");
617 ············Assert.That(Guid.Empty ==··cont.PubValType.EmptyGuidVar, "EmptyGuidVar falsch #2");
618 ············Assert.That(DateTime.MinValue ==··cont.PubValType.EmptyDateTimeVar, "EmptyDateTimeVar falsch #2");
619 ············Assert.That(cont.PubValType.NullString == null, "Empty String falsch #1");
620
621 ············Assert.That(0x55 ==··cont.EmbeddedType.ByteVar, "ByteVar falsch #3");
622 ············Assert.That(true ==·· cont.EmbeddedType.BoolVar, "BoolVar falsch #3");
623 ············Assert.That(12.34m ==··cont.EmbeddedType.DecVar, "DecVar falsch #3");
624 #if !FIREBIRD && !POSTGRE
625 ············Assert.That(new DateTime(2002, 12, 1, 1, 0, 20) == cont.EmbeddedType.DateTimeVar, "DateTimeVar falsch #2");
626 #else
627 ············Assert.That(new DateTime(2002, 12, 1, 0, 0, 0) == cont.EmbeddedType.DateTimeVar, "DateTimeVar falsch #2");
628 #endif
629 #if SQLITE
630 ············Assert.That( CheckDouble( 12345.123456, cont.PropValType.DoubleVar ), "DoubleVar falsch #1" );
631 ············Assert.That( CheckFloat( 12345.1f, cont.PropValType.FloatVar ), "FloatVar falsch #1" );
632 #else
633 ············Assert.That(12345.123456 ==··cont.EmbeddedType.DoubleVar, "DoubleVar falsch #3");
634 ············Assert.That(12345.1f ==··cont.EmbeddedType.FloatVar, "FloatVar falsch #3");
635 #endif
636 ············Assert.That(new Guid("12341234-1234-1234-1234-123412341234") ==··cont.EmbeddedType.GuidVar, "GuidVar falsch #3");
637 ············Assert.That(0x1234 ==··cont.EmbeddedType.Int16Var, "Int16Var falsch #3");
638 ············Assert.That(0x12341234 ==··cont.EmbeddedType.Int32Var, "Int32Var falsch #3");
639 ············Assert.That(0x143214321 ==··cont.EmbeddedType.Int64Var, "Int64Var falsch #3");
640 ············Assert.That("Teststring" ==··cont.EmbeddedType.StringVar, "StringVar falsch #3");
641 ············Assert.That(0xabc ==··cont.EmbeddedType.Uint16Var, "Uint16Var falsch #3");
642 ············Assert.That(0x12341234 ==··cont.EmbeddedType.Uint32Var, "Uint32Var falsch #3");
643 ············Assert.That(0x143214321 ==··cont.EmbeddedType.Uint64Var, "Uint64Var falsch #3");
644 ············Assert.That(EnumType.drei ==··cont.EmbeddedType.EnumVar, "EnumVar falsch #3");
645 ············Assert.That(Guid.Empty ==··cont.EmbeddedType.EmptyGuidVar, "EmptyGuidVar falsch #3");
646 ············Assert.That(DateTime.MinValue ==··cont.EmbeddedType.EmptyDateTimeVar, "EmptyDateTimeVar falsch #3");
647 ············Assert.That(cont.EmbeddedType.NullString == null, "Empty String falsch #1");
648 ········}
649 ····}
650 }
651
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.Reflection;
25 using System.Collections;
26 using DataTypeTestClasses;
27 using NDO;
28 using NDO.Mapping;
29 using NUnit.Framework;
30 using NDO.Query;
31 using System.Linq;
32
33 namespace NdoUnitTests
34 {
35 ····[TestFixture]
36 public class DataTypeTest : NDOTest
37 ····{
38 ········[SetUp]
39 ········public void Setup()
40 ········{
41 ········}
42
43 ········[TearDown]
44 ········public void TearDown()
45 ········{
46 ············var pm = PmFactory.NewPersistenceManager();
47
48 ············IList l = pm.GetClassExtent(typeof(DataContainer), true);
49 ············if (l.Count > 0)
50 ············{
51 ················pm.Delete( l );
52 ················pm.Save();
53 ············}
54 ············l = pm.GetClassExtent( typeof( DataContainerDerived ), true );
55 ············if (l.Count > 0)
56 ············{
57 ················pm.Delete( l );
58 ················pm.Save();
59 ············}
60 ············l = pm.GetClassExtent( typeof( VtAndEtContainer ), true );
61 ············if (l.Count > 0)
62 ············{
63 ················pm.Delete( l );
64 ················pm.Save();
65 ············}
66 ············l = pm.GetClassExtent( typeof( VtAndEtContainerDerived ), true );
67 ············if (l.Count > 0)
68 ············{
69 ················pm.Delete( l );
70 ················pm.Save();
71 ············}
72 ············l = pm.GetClassExtent( typeof( NullableDataContainer ), true );
73 ············if (l.Count > 0)
74 ············{
75 ················pm.Delete( l );
76 ················pm.Save();
77 ············}
78 ············l = pm.GetClassExtent( typeof( NullableDataContainerDerived ), true );
79 ············if (l.Count > 0)
80 ············{
81 ················pm.Delete( l );
82 ················pm.Save();
83 ············}
84
85 ············pm.Close();
86 ········}
87
88 ········[Test]
89 ········public void TestDataContainer()
90 ········{
91 ············DataContainer dc = new DataContainer();
92
93 ············dc.Init();
94
95 ············var pm = PmFactory.NewPersistenceManager();
96
97 ············pm.MakePersistent(dc);
98 ············pm.Save();
99 ············pm.UnloadCache();
100 ············IList l = pm.GetClassExtent(typeof(DataContainer));
101 ············Assert.That(1 ==··l.Count, "Ein Objekt sollte in der Liste sein");
102 ············dc = (DataContainer) l[0];
103 ············AssertDataContainer(dc);
104 ········}
105
106 ········[Test]
107 ········public void TestNullableDataContainer()
108 ········{
109 ············NullableDataContainer ndc = new NullableDataContainer();
110 ············ndc.Init();
111
112 ············var pm = PmFactory.NewPersistenceManager();
113 ············pm.MakePersistent(ndc);
114 ············pm.Save();
115 ············pm.UnloadCache();
116 ············ndc = new NDOQuery<NullableDataContainer>(pm, null, false).ExecuteSingle(true);
117 ············AssertNullableDataContainer(ndc);
118 ········}
119
120
121 ········[Test]
122 ········public void TestNullableDataContainerDerived()
123 ········{
124 ············NullableDataContainerDerived ndc = new NullableDataContainerDerived();
125 ············ndc.Init();
126
127 ············var pm = PmFactory.NewPersistenceManager();
128 ············pm.MakePersistent(ndc);
129 ············pm.Save();
130 ············pm.UnloadCache();
131 ············ndc = new NDOQuery<NullableDataContainerDerived>(pm, null, false).ExecuteSingle(true);
132 ············AssertNullableDataContainer(ndc);
133 ········}
134
135 ········private bool FieldWithNameExists(Class cl, string name)
136 ········{
137 ············foreach(Field field in cl.Fields)
138 ················if (field.Name.IndexOf(name) > -1)
139 ····················return true;
140 ············return false;
141 ········}
142
143 ········//public void TestDataContainerEvent()
144 ········//{
145 ········//····Type t = typeof(DataContainer.QueryHelper);
146
147 ········//····Class cl = pm.NDOMapping.FindClass(typeof(DataContainer));
148 ········//····Assert.That(cl.FindField("TestEvent") == null, "Events should not be mapped");
149
150 ········//····Assert.That(t.GetMember("int16Var" != null, BindingFlags.Instance), "Variables should appear in qh");
151 ········//····PropertyInfo pi = t.GetProperty("TestEvent");
152 ········//····Assert.That(pi == null, "Events should not appear in qh");
153
154 ········//····//----
155 ········//····t = typeof(DataContainerDerived.QueryHelper);
156
157 ········//····cl = pm.NDOMapping.FindClass(typeof(DataContainerDerived));
158 ········//····Assert.That(!FieldWithNameExists(cl, "TestEvent"), "Events should not be mapped");
159
160 ········//····Assert.That(t.GetMember("int16Var" != null, BindingFlags.Instance), "Variables should appear in qh");
161 ········//····pi = t.GetProperty("TestEvent");
162 ········//····Assert.That(pi == null, "Events should not appear in qh");
163
164 ········//····//----
165 ········//····t = typeof(VtAndEtContainer.QueryHelper);
166
167 ········//····cl = pm.NDOMapping.FindClass(typeof(VtAndEtContainer));
168 ········//····Assert.That(!FieldWithNameExists(cl, "TestEvent"), "Events should not be mapped");
169
170 ········//····Assert.That(t.GetMember("int16Var" != null, BindingFlags.Instance), "Variables should appear in qh");
171 ········//····pi = t.GetProperty("TestEvent");
172 ········//····Assert.That(pi == null, "Events should not appear in qh");
173
174 ········//····//----
175 ········//····t = typeof(VtAndEtContainerDerived.QueryHelper);
176
177 ········//····cl = pm.NDOMapping.FindClass(typeof(VtAndEtContainerDerived));
178 ········//····Assert.That(!FieldWithNameExists(cl, "TestEvent"), "Events should not be mapped");
179
180 ········//····Assert.That(t.GetMember("int16Var" != null, BindingFlags.Instance), "Variables should appear in qh");
181 ········//····pi = t.GetProperty("TestEvent");
182 ········//····Assert.That(pi == null, "Events should not appear in qh");
183
184 ········//}
185
186 ········[Test]
187 ········public void TestDataContainerDerived()
188 ········{············
189 ············DataContainerDerived dcd = new DataContainerDerived();
190 ············dcd.Init();
191 ············var pm = PmFactory.NewPersistenceManager();
192 ············pm.MakePersistent(dcd);
193 ············pm.Save();
194 ············pm.UnloadCache();
195 ············IList l = pm.GetClassExtent(typeof(DataContainerDerived));
196 ············Assert.That(1 ==··l.Count, "Ein Objekt sollte in der Liste sein");
197 ············dcd = (DataContainerDerived) l[0];
198 ············AssertDataContainer(dcd);
199 ········}
200
201 ········bool CheckDouble( double d1, double d2 )
202 ········{
203 ············double eps = Math.Abs(d1 * 1E-6);
204 ············return (d1 - eps) <= d2 && d2 <= (d1 + eps);
205 ········}
206
207 ········bool CheckFloat( float d1, float d2 )
208 ········{
209 ············double eps = Math.Abs( d1 * 1E-6 );
210 ············return (d1 - eps) <= d2 && d2 <= (d1 + eps);
211 ········}
212
213 ········void AssertDataContainer(DataContainer dc)
214 ········{
215 ············Assert.That(true ==··dc.BoolVar, "BoolVar falsc h");
216 ············Assert.That(127 ==··dc.ByteVar, "ByteVar falsch");
217 ············Assert.That("Test" ==··dc.StringVar, "StringVar falsch");
218 ············Assert.That(DateTime.Now.Date ==··dc.DateTimeVar.Date, "DateTimeVar falsch");
219 ············Assert.That(new Guid("12341234-1234-1234-1234-123412341234") ==··dc.GuidVar, "GuidVar falsch");
220 ············Assert.That(1231.12m ==··dc.DecVar, "DecVar falsch");
221 ············Assert.That(int.MaxValue ==··dc.Int32Var, "Int32Var falsch");
222 ············Assert.That((uint) int.MaxValue ==··dc.Uint32Var, "UInt32Var falsch");
223 #if SQLITE
224 ············Assert.That(CheckDouble(1E28, dc.DoubleVar), "DoubleVar falsch");
225 ············Assert.That(CheckFloat(1E14F, dc.FloatVar), "FloatVar falsch");
226 #else
227 ············Assert.That(1E28 ==··dc.DoubleVar, "DoubleVar falsch");
228 ············Assert.That(1E14F ==··dc.FloatVar, "FloatVar falsch");
229 #endif
230 ············Assert.That(0x1ffffffff ==··dc.Int64Var, "Int64Var falsch");
231 ············Assert.That(short.MaxValue ==··dc.Int16Var, "Int16Var falsch");
232 ············Assert.That((ushort) short.MaxValue ==··dc.Uint16Var, "UInt16Var falsch");
233 ············Assert.That(0x1ffffffff ==··dc.Uint64Var, "UInt64Var falsch");
234 ············Assert.That(EnumType.drei ==··dc.EnumVar, "EnumType falsch");
235 ············Assert.That(Guid.Empty ==··dc.EmptyGuidVar, "Empty Guid falsch");
236 ············Assert.That(DateTime.MinValue ==··dc.EmptyDateTimeVar, "Empty DateTime falsch");
237 ············Assert.That(dc.NullString == null, "Empty String falsch");
238 ········}
239
240
241 ········void AssertNullableDataContainer(NullableDataContainer dc)
242 ········{
243 ············Assert.That(true ==··dc.BoolVar, "BoolVar falsch");
244 ············Assert.That(127 ==··dc.ByteVar, "ByteVar falsch");
245 ············Assert.That(DateTime.Now.Date ==··dc.DateTimeVar.Value.Date, "DateTimeVar falsch");
246 ············Assert.That(new Guid("12341234-1234-1234-1234-123412341234") ==··dc.GuidVar, "GuidVar falsch");
247 ············Assert.That(1231.12m ==··dc.DecVar, "DecVar falsch");
248 ············Assert.That(int.MaxValue ==··dc.Int32Var, "Int32Var falsch");
249 ············Assert.That((uint)int.MaxValue ==··dc.Uint32Var, "UInt32Var falsch");
250 #if SQLITE
251 ············Assert.That(CheckDouble(1E28, dc.DoubleVar.Value), "DoubleVar falsch");
252 ············Assert.That(CheckFloat(1E14F, dc.FloatVar.Value), "FloatVar falsch");
253 #else
254 ············Assert.That(1E28 ==··dc.DoubleVar.Value, "DoubleVar falsch");
255 ············Assert.That(1E14F ==··dc.FloatVar.Value, "FloatVar falsch");
256 #endif
257 ············Assert.That(0x1ffffffff ==··dc.Int64Var, "Int64Var falsch");
258 ············Assert.That(short.MaxValue ==··dc.Int16Var, "Int16Var falsch");
259 ············Assert.That((ushort)short.MaxValue ==··dc.Uint16Var, "UInt16Var falsch");
260 ············Assert.That(0x1ffffffff ==··dc.Uint64Var, "UInt64Var falsch");
261 ············Assert.That(EnumType.drei ==··dc.EnumVar, "EnumType falsch");
262
263 #if !ACCESS··// Access initializes bool vars always with False
264 ············Assert.That(!dc.BoolEmptyVar.HasValue, "BoolEmptyVar falsch");
265 #endif
266 ············Assert.That(!dc.ByteEmptyVar.HasValue, "ByteVar falsch");
267 ············Assert.That(!dc.DateTimeEmptyVar.HasValue, "DateTimeVar falsch");
268 ············Assert.That(!dc.GuidEmptyVar.HasValue, "GuidVar falsch");
269 ············Assert.That(!dc.DecEmptyVar.HasValue, "DecVar falsch");
270 ············Assert.That(!dc.Int32EmptyVar.HasValue, "Int32Var falsch");
271 ············Assert.That(!dc.Uint32EmptyVar.HasValue, "UInt32Var falsch");
272 ············Assert.That(!dc.DoubleEmptyVar.HasValue, "DoubleVar falsch");
273 ············Assert.That(!dc.FloatEmptyVar.HasValue, "FloatVar falsch");
274 ············Assert.That(!dc.Int64EmptyVar.HasValue, "Int64Var falsch");
275 ············Assert.That(!dc.Int16EmptyVar.HasValue, "Int16Var falsch");
276 ············Assert.That(!dc.Uint16EmptyVar.HasValue, "UInt16Var falsch");
277 ············Assert.That(!dc.Uint64EmptyVar.HasValue, "UInt64Var falsch");
278 ············Assert.That(!dc.EnumEmptyVar.HasValue, "EnumType falsch");
279
280 ········}
281
282 ········[Test]
283 ········public void QueryWithEmptyGuidParameterSearchesForNull()
284 ········{
285 ············var pm = PmFactory.NewPersistenceManager();
286
287 ············DataContainer dc = new DataContainer();
288 ············dc.Init();
289 ············dc.GuidVar = Guid.Empty;
290 ············pm.MakePersistent( dc );
291 ············pm.Save();
292 ············pm.UnloadCache();
293
294 ············var q = new NDOQuery<DataContainer>(pm, "guidVar = {0}");
295 ············q.Parameters.Add( Guid.Empty );
296 ············var list = q.Execute();
297 ············Assert.That(Guid.Empty ==··list.First().GuidVar );
298 ········}
299
300 ········[Test]
301 ········public void QueryWithDateTimeMinValueParameterSearchesForNull()
302 ········{
303 ············var pm = PmFactory.NewPersistenceManager();
304
305 ············DataContainer dc = new DataContainer();
306
307 ············dc.Init();
308 ············dc.DateTimeVar = DateTime.MinValue;
309 ············pm.MakePersistent( dc );
310 ············pm.Save();
311 ············pm.UnloadCache();
312
313 ············var q = new NDOQuery<DataContainer>(pm, "dateTimeVar = {0}");
314 ············q.Parameters.Add( DateTime.MinValue );
315 ············var list = q.Execute();
316 ············Assert.That(DateTime.MinValue ==··list.First().DateTimeVar );
317 ········}
318
319
320 ········[Test]
321 ········public void ParametersTest()
322 ········{
323 ············var pm = PmFactory.NewPersistenceManager();
324
325 ············DataContainer dc = new DataContainer();
326 ············dc.Init();
327 ············pm.MakePersistent(dc);
328 ············pm.Save();
329 ············IQuery q = new NDOQuery<DataContainer>(pm, "boolVar" + " = " + "{0}");
330 #if !ORACLE
331 ············q.Parameters.Add(true);
332 #else
333 ············q.Parameters.Add(1);
334 #endif
335 ············q.ExecuteSingle(true);··// If something goes wrong, an Exception will be thrown.
336 ············
337 ············q = new NDOQuery<DataContainer>(pm, "byteVar" + " = " + "{0}");
338 ············q.Parameters.Add((byte)127);
339 ············q.ExecuteSingle(true);··// If something goes wrong, an Exception will be thrown.
340
341 ············q = new NDOQuery<DataContainer>(pm, "dateTimeVar" + " <= " + "{0}");
342 ············q.Parameters.Add(DateTime.Now);
343 ············q.ExecuteSingle(true);··// If something goes wrong, an Exception will be thrown.
344
345 ············q = new NDOQuery<DataContainer>(pm, "guidVar" + " = " + "{0}");
346 ············q.Parameters.Add(new Guid("12341234-1234-1234-1234-123412341234"));
347 ············q.ExecuteSingle(true);··// If something goes wrong, an Exception will be thrown.
348
349 ············q = new NDOQuery<DataContainer>(pm, "decVar" + " = " + "{0}");
350 ············q.Parameters.Add(1231.12m);
351 ············q.ExecuteSingle(true);··// If something goes wrong, an Exception will be thrown.
352
353 ············q = new NDOQuery<DataContainer>(pm, "doubleVar" + " = " + "{0}");
354 ············q.Parameters.Add(1E28);
355 ············q.ExecuteSingle(true);··// If something goes wrong, an Exception will be thrown.
356
357 ············q = new NDOQuery<DataContainer>(pm, "enumVar" + " = " + "{0}");
358 ············q.Parameters.Add(EnumType.drei);
359 ············q.ExecuteSingle(true);··// If something goes wrong, an Exception will be thrown.
360
361 #if !MYSQL
362 ············q = new NDOQuery<DataContainer>(pm, "floatVar" + " = " + "{0}");
363 ············q.Parameters.Add(1E14F);
364 ············q.ExecuteSingle(true);··// If something goes wrong, an Exception will be thrown.
365 #endif
366 ············q = new NDOQuery<DataContainer>(pm, "int16Var" + " = " + "{0}");
367 ············q.Parameters.Add(short.MaxValue);
368 ············q.ExecuteSingle(true);··// If something goes wrong, an Exception will be thrown.
369
370 ············q = new NDOQuery<DataContainer>(pm, "int32Var" + " = " + "{0}");
371 ············q.Parameters.Add(int.MaxValue);
372 ············q.ExecuteSingle(true);··// If something goes wrong, an Exception will be thrown.
373
374 ············q = new NDOQuery<DataContainer>(pm, "int64Var" + " = " + "{0}");
375 ············q.Parameters.Add(0x1ffffffff);
376 ············q.ExecuteSingle(true);··// If something goes wrong, an Exception will be thrown.
377
378 ············q = new NDOQuery<DataContainer>(pm, "stringVar" + " = " + "{0}");
379 ············q.Parameters.Add("Test");
380 ············q.ExecuteSingle(true);··// If something goes wrong, an Exception will be thrown.
381
382 ············q = new NDOQuery<DataContainer>(pm, "uint16Var" + " = " + "{0}");
383 ············q.Parameters.Add((ushort) short.MaxValue);
384 ············q.ExecuteSingle(true);··// If something goes wrong, an Exception will be thrown.
385
386 ············q = new NDOQuery<DataContainer>(pm, "uint32Var" + " = " + "{0}");
387 ············q.Parameters.Add((uint) int.MaxValue);
388 ············q.ExecuteSingle(true);··// If something goes wrong, an Exception will be thrown.
389
390 ············q = new NDOQuery<DataContainer>(pm, "uint64Var" + " = " + "{0}");
391 ············q.Parameters.Add(0x1ffffffff);
392 ············dc = (DataContainer) q.ExecuteSingle(true);··// If something goes wrong, an Exception will be thrown.
393
394 ············dc.StringVar = "";
395 ············pm.Save();
396
397 #if ORACLE
398 ············q = new NDOQuery<DataContainer>(pm, "stringVar" + Query.Op.IsNull);
399 ············q.ExecuteSingle(true);··// If something goes wrong, an Exception will be thrown.
400 #else
401 ············q = new NDOQuery<DataContainer>(pm, "stringVar" + " = " + "{0}");
402 ············q.Parameters.Add("");
403 ············q.ExecuteSingle(true);··// If something goes wrong, an Exception will be thrown.
404 #endif
405
406 ········}
407
408
409 #if nix
410 ········[Test]
411 ········public void TestQueryHelpers()
412 ········{············
413 ············Assert.That("propValType.ByteVar" ==··"propValType.ByteVar", "ByteVar falsch #1");
414 ············Assert.That("propValType.BoolVar" ==·· "propValType.BoolVar", "BoolVar falsch #1");
415 ············Assert.That("propValType.DecVar" ==··"propValType.DecVar", "DecVar falsch #1");
416 ············Assert.That("propValType.DateTimeVar" ==··"propValType.DateTimeVar", "DateTimeVar falsch #1");
417 ············Assert.That("propValType.DoubleVar" ==··"propValType.DoubleVar", "DoubleVar falsch #1");
418 ············Assert.That("propValType.FloatVar" ==··"propValType.FloatVar", "FloatVar falsch #1");
419 ············Assert.That("propValType.GuidVar" ==··"propValType.GuidVar", "GuidVar falsch #1");
420 ············Assert.That("propValType.Int16Var" ==··"propValType.Int16Var", "Int16Var falsch #1");
421 ············Assert.That("propValType.Int32Var" ==··"propValType.Int32Var", "Int32Var falsch #1");
422 ············Assert.That("propValType.Int64Var" ==··"propValType.Int64Var", "Int64Var falsch #1");
423 ············Assert.That("propValType.StringVar" ==··"propValType.StringVar", "StringVar falsch #1");
424 ············Assert.That("propValType.Uint16Var" ==··"propValType.Uint16Var", "Uint16Var falsch #1");
425 ············Assert.That("propValType.Uint32Var" ==··"propValType.Uint32Var", "Uint32Var falsch #1");
426 ············Assert.That("propValType.Uint64Var" ==··"propValType.Uint64Var", "Uint64Var falsch #1");
427 ············Assert.That("propValType.EnumVar" ==··"propValType.EnumVar", "EnumVar falsch #1");
428
429 ············Assert.That("pubValType.ByteVar" ==··"pubValType.ByteVar", "ByteVar falsch #2");
430 ············Assert.That("pubValType.BoolVar" ==·· "pubValType.BoolVar", "BoolVar falsch #2");
431 ············Assert.That("pubValType.DecVar" ==··"pubValType.DecVar", "DecVar falsch #2");
432 ············Assert.That("pubValType.DateTimeVar" ==··"pubValType.DateTimeVar", "DateTimeVar falsch #2");
433 ············Assert.That("pubValType.DoubleVar" ==··"pubValType.DoubleVar", "DoubleVar falsch #2");
434 ············Assert.That("pubValType.FloatVar" ==··"pubValType.FloatVar", "FloatVar falsch #2");
435 ············Assert.That("pubValType.GuidVar" ==··"pubValType.GuidVar", "GuidVar falsch #2");
436 ············Assert.That("pubValType.Int16Var" ==··"pubValType.Int16Var", "Int16Var falsch #2");
437 ············Assert.That("pubValType.Int32Var" ==··"pubValType.Int32Var", "Int32Var falsch #2");
438 ············Assert.That("pubValType.Int64Var" ==··"pubValType.Int64Var", "Int64Var falsch #2");
439 ············Assert.That("pubValType.StringVar" ==··"pubValType.StringVar", "StringVar falsch #2");
440 ············Assert.That("pubValType.Uint16Var" ==··"pubValType.Uint16Var", "Uint16Var falsch #2");
441 ············Assert.That("pubValType.Uint32Var" ==··"pubValType.Uint32Var", "Uint32Var falsch #2");
442 ············Assert.That("pubValType.Uint64Var" ==··"pubValType.Uint64Var", "Uint64Var falsch #2");
443 ············Assert.That("pubValType.EnumVar" ==··"pubValType.EnumVar", "EnumVar falsch #2");
444
445 ············Assert.That("embeddedType.byteVar" ==··"embeddedType.byteVar", "ByteVar falsch #3");
446 ············Assert.That("embeddedType.boolVar" ==·· "embeddedType.boolVar", "BoolVar falsch #3");
447 ············Assert.That("embeddedType.decVar" ==··"embeddedType.decVar", "DecVar falsch #3");
448 ············Assert.That("embeddedType.dateTimeVar" ==··"embeddedType.dateTimeVar", "DateTimeVar falsch #3");
449 ············Assert.That("embeddedType.doubleVar" ==··"embeddedType.doubleVar", "DoubleVar falsch #3");
450 ············Assert.That("embeddedType.floatVar" ==··"embeddedType.floatVar", "FloatVar falsch #3");
451 ············Assert.That("embeddedType.guidVar" ==··"embeddedType.guidVar", "GuidVar falsch #3");
452 ············Assert.That("embeddedType.int16Var" ==··"embeddedType.int16Var", "Int16Var falsch #3");
453 ············Assert.That("embeddedType.int32Var" ==··"embeddedType.int32Var", "Int32Var falsch #3");
454 ············Assert.That("embeddedType.int64Var" ==··"embeddedType.int64Var", "Int64Var falsch #3");
455 ············Assert.That("embeddedType.stringVar" ==··"embeddedType.stringVar", "StringVar falsch #3");
456 ············Assert.That("embeddedType.uint16Var" ==··"embeddedType.uint16Var", "Uint16Var falsch #3");
457 ············Assert.That("embeddedType.uint32Var" ==··"embeddedType.uint32Var", "Uint32Var falsch #3");
458 ············Assert.That("embeddedType.uint64Var" ==··"embeddedType.uint64Var", "Uint64Var falsch #3");
459 ············Assert.That("embeddedType.enumVar" ==··"embeddedType.enumVar", "Uint64Var falsch #3");
460
461 ············VtAndEtContainerDerived.QueryHelper "" = new VtAndEtContainerDerived.QueryHelper();
462 ············
463 ············Assert.That("propValType.ByteVar" ==··".propValType.ByteVar", "ByteVar falsch #1");
464 ············Assert.That("propValType.BoolVar" ==·· ".propValType.BoolVar", "BoolVar falsch #1");
465 ············Assert.That("propValType.DecVar" ==··".propValType.DecVar", "DecVar falsch #1");
466 ············Assert.That("propValType.DateTimeVar" ==··".propValType.DateTimeVar", "DateTimeVar falsch #1");
467 ············Assert.That("propValType.DoubleVar" ==··".propValType.DoubleVar", "DoubleVar falsch #1");
468 ············Assert.That("propValType.FloatVar" ==··".propValType.FloatVar", "FloatVar falsch #1");
469 ············Assert.That("propValType.GuidVar" ==··".propValType.GuidVar", "GuidVar falsch #1");
470 ············Assert.That("propValType.Int16Var" ==··".propValType.Int16Var", "Int16Var falsch #1");
471 ············Assert.That("propValType.Int32Var" ==··".propValType.Int32Var", "Int32Var falsch #1");
472 ············Assert.That("propValType.Int64Var" ==··".propValType.Int64Var", "Int64Var falsch #1");
473 ············Assert.That("propValType.StringVar" ==··".propValType.StringVar", "StringVar falsch #1");
474 ············Assert.That("propValType.Uint16Var" ==··".propValType.Uint16Var", "Uint16Var falsch #1");
475 ············Assert.That("propValType.Uint32Var" ==··".propValType.Uint32Var", "Uint32Var falsch #1");
476 ············Assert.That("propValType.Uint64Var" ==··".propValType.Uint64Var", "Uint64Var falsch #1");
477 ············Assert.That("propValType.EnumVar" ==··".propValType.EnumVar", "EnumVar falsch #1");
478
479 ············Assert.That("pubValType.ByteVar" ==··".pubValType.ByteVar", "ByteVar falsch #2");
480 ············Assert.That("pubValType.BoolVar" ==·· ".pubValType.BoolVar", "BoolVar falsch #2");
481 ············Assert.That("pubValType.DecVar" ==··".pubValType.DecVar", "DecVar falsch #2");
482 ············Assert.That("pubValType.DateTimeVar" ==··".pubValType.DateTimeVar", "DateTimeVar falsch #2");
483 ············Assert.That("pubValType.DoubleVar" ==··".pubValType.DoubleVar", "DoubleVar falsch #2");
484 ············Assert.That("pubValType.FloatVar" ==··".pubValType.FloatVar", "FloatVar falsch #2");
485 ············Assert.That("pubValType.GuidVar" ==··".pubValType.GuidVar", "GuidVar falsch #2");
486 ············Assert.That("pubValType.Int16Var" ==··".pubValType.Int16Var", "Int16Var falsch #2");
487 ············Assert.That("pubValType.Int32Var" ==··".pubValType.Int32Var", "Int32Var falsch #2");
488 ············Assert.That("pubValType.Int64Var" ==··".pubValType.Int64Var", "Int64Var falsch #2");
489 ············Assert.That("pubValType.StringVar" ==··".pubValType.StringVar", "StringVar falsch #2");
490 ············Assert.That("pubValType.Uint16Var" ==··".pubValType.Uint16Var", "Uint16Var falsch #2");
491 ············Assert.That("pubValType.Uint32Var" ==··".pubValType.Uint32Var", "Uint32Var falsch #2");
492 ············Assert.That("pubValType.Uint64Var" ==··".pubValType.Uint64Var", "Uint64Var falsch #2");
493 ············Assert.That("pubValType.EnumVar" ==··".pubValType.EnumVar", "EnumVar falsch #2");
494
495 ············Assert.That("embeddedType.byteVar" ==··".embeddedType.byteVar", "ByteVar falsch #3");
496 ············Assert.That("embeddedType.boolVar" ==·· ".embeddedType.boolVar", "BoolVar falsch #3");
497 ············Assert.That("embeddedType.decVar" ==··".embeddedType.decVar", "DecVar falsch #3");
498 ············Assert.That("embeddedType.dateTimeVar" ==··".embeddedType.dateTimeVar", "DateTimeVar falsch #3");
499 ············Assert.That("embeddedType.doubleVar" ==··".embeddedType.doubleVar", "DoubleVar falsch #3");
500 ············Assert.That("embeddedType.floatVar" ==··".embeddedType.floatVar", "FloatVar falsch #3");
501 ············Assert.That("embeddedType.guidVar" ==··".embeddedType.guidVar", "GuidVar falsch #3");
502 ············Assert.That("embeddedType.int16Var" ==··".embeddedType.int16Var", "Int16Var falsch #3");
503 ············Assert.That("embeddedType.int32Var" ==··".embeddedType.int32Var", "Int32Var falsch #3");
504 ············Assert.That("embeddedType.int64Var" ==··".embeddedType.int64Var", "Int64Var falsch #3");
505 ············Assert.That("embeddedType.stringVar" ==··".embeddedType.stringVar", "StringVar falsch #3");
506 ············Assert.That("embeddedType.uint16Var" ==··".embeddedType.uint16Var", "Uint16Var falsch #3");
507 ············Assert.That("embeddedType.uint32Var" ==··".embeddedType.uint32Var", "Uint32Var falsch #3");
508 ············Assert.That("embeddedType.uint64Var" ==··".embeddedType.uint64Var", "Uint64Var falsch #3");
509 ············Assert.That("embeddedType.enumVar" ==··".embeddedType.enumVar", "Uint64Var falsch #3");
510
511 ········}
512 #endif
513
514 ········[Test]
515 ········public void TestPrimitiveTypeMethodCall()
516 ········{
517 ············PrimitiveTypeMethodCaller mc1 = new PrimitiveTypeMethodCaller();
518 ············PrimitiveTypeMethodCaller mc2 = new PrimitiveTypeMethodCaller();
519 ············Assert.That(0 ==··mc1.StringTest(mc2), "Result must be 0 #1");
520 ············Assert.That(0 ==··mc1.DoubleTest(mc2), "Result must be 0 #2");
521 ············Assert.That(0 ==··mc1.DateTimeTest(mc2), "Result must be 0 #3");
522 ············Assert.That(0 ==··mc1.BoolTest(mc2), "Result must be 0 #4");
523 ············Assert.That(0 ==··mc1.IntTest(mc2), "Result must be 0 #5");
524 ········}
525
526 ········[Test]
527 ········public void TestValueTypeAndEmbeddedType()
528 ········{
529 ············var pm = PmFactory.NewPersistenceManager();
530
531 ············Class cl = pm.NDOMapping.FindClass("DataTypeTestClasses.VtAndEtContainer");
532 ············Field f = cl.FindField("embeddedType.doubleVar");
533 ············f.Column.Size = 12;
534 ············f.Column.Precision = 7;
535 ············VtAndEtContainer cont = new VtAndEtContainer();
536 ············cont.Init();
537 ············pm.MakePersistent(cont);
538 ············pm.Save();
539 ············pm.UnloadCache();
540 ············IList l = pm.GetClassExtent(typeof(VtAndEtContainer));
541 ············Assert.That(1 ==··l.Count, "Anzahl Container stimmt nicht");
542 ············cont = (VtAndEtContainer) l[0];
543 ············AssertVtAndEtContainer(cont);········
544 ········}
545
546 ········[Test]
547 ········public void TestValueTypeAndEmbeddedTypeDerived()
548 ········{
549 ············var pm = PmFactory.NewPersistenceManager();
550
551 ············VtAndEtContainerDerived cont = new VtAndEtContainerDerived();
552 ············cont.Init();
553 ············pm.MakePersistent(cont);
554 ············pm.Save();
555 ············pm.UnloadCache();
556 ············IList l = pm.GetClassExtent(typeof(VtAndEtContainerDerived));
557 ············Assert.That(1 ==··l.Count, "Anzahl Container stimmt nicht");
558 ············cont = (VtAndEtContainerDerived) l[0];
559 ············AssertVtAndEtContainer(cont);········
560 ········}
561
562
563 ········void AssertVtAndEtContainer(VtAndEtContainer cont)
564 ········{
565 ············Assert.That(0x55 ==··cont.PropValType.ByteVar, "ByteVar falsch #1");
566 ············Assert.That(true ==·· cont.PropValType.BoolVar, "BoolVar falsch #1");
567 ············Assert.That(12.34m ==··cont.PropValType.DecVar, "DecVar falsch #1");
568 #if !FIREBIRD && !POSTGRE
569 ············Assert.That(new DateTime(2002, 12, 1, 1, 0, 20) == cont.PropValType.DateTimeVar, "DateTimeVar falsch #1");
570 #else
571 ············Assert.That(new DateTime(2002, 12, 1, 0, 0, 0) == cont.PropValType.DateTimeVar, "DateTimeVar falsch #1");
572 #endif
573 #if SQLITE
574 ············Assert.That( CheckDouble( 12345.123456, cont.PropValType.DoubleVar ), "DoubleVar falsch #1" );
575 ············Assert.That( CheckFloat( 12345.1f, cont.PropValType.FloatVar ), "FloatVar falsch #1" );
576 #else
577 ············Assert.That(12345.123456 ==··cont.PropValType.DoubleVar, "DoubleVar falsch #1");
578 ············Assert.That(12345.1f ==··cont.PropValType.FloatVar, "FloatVar falsch #1");
579 #endif
580 ············Assert.That(new Guid("12341234-1234-1234-1234-123412341234") ==··cont.PropValType.GuidVar, "GuidVar falsch #1");
581 ············Assert.That(0x1234 ==··cont.PropValType.Int16Var, "Int16Var falsch #1");
582 ············Assert.That(0x12341234 ==··cont.PropValType.Int32Var, "Int32Var falsch #1");
583 ············Assert.That(0x143214321 ==··cont.PropValType.Int64Var, "Int64Var falsch #1");
584 ············Assert.That("Teststring" ==··cont.PropValType.StringVar, "StringVar falsch #1");
585 ············Assert.That(0xabc ==··cont.PropValType.Uint16Var, "Uint16Var falsch #1");
586 ············Assert.That(0x12341234 ==··cont.PropValType.Uint32Var, "Uint32Var falsch #1");
587 ············Assert.That(0x143214321 ==··cont.PropValType.Uint64Var, "Uint64Var falsch #1");
588 ············Assert.That(EnumType.zwei ==··cont.PropValType.EnumVar, "EnumVar falsch #1");
589 ············Assert.That(Guid.Empty ==··cont.PropValType.EmptyGuidVar, "EmptyGuidVar falsch #1");
590 ············Assert.That(DateTime.MinValue ==··cont.PropValType.EmptyDateTimeVar, "EmptyDateTimeVar falsch #1");
591 ············Assert.That(cont.PropValType.NullString == null, "Empty String falsch #1");
592
593 ············Assert.That(0x55 ==··cont.PubValType.ByteVar, "ByteVar falsch #2");
594 ············Assert.That(true ==·· cont.PubValType.BoolVar, "BoolVar falsch #2");
595 ············Assert.That(12.34m ==··cont.PubValType.DecVar, "DecVar falsch #2");
596 #if !FIREBIRD && !POSTGRE
597 ············Assert.That(new DateTime(2002, 12, 1, 1, 0, 20) == cont.PubValType.DateTimeVar, "DateTimeVar falsch #2");
598 #else
599 ············Assert.That(new DateTime(2002, 12, 1, 0, 0, 0) == cont.PubValType.DateTimeVar, "DateTimeVar falsch #2");
600 #endif
601 #if SQLITE
602 ············Assert.That( CheckDouble( 12345.123456, cont.PropValType.DoubleVar ), "DoubleVar falsch #1" );
603 ············Assert.That( CheckFloat( 12345.1f, cont.PropValType.FloatVar ), "FloatVar falsch #1" );
604 #else
605 ············Assert.That(12345.123456 ==··cont.PubValType.DoubleVar, "DoubleVar falsch #2");
606 ············Assert.That(12345.1f ==··cont.PubValType.FloatVar, "FloatVar falsch #2");
607 #endif
608 ············Assert.That(new Guid("12341234-1234-1234-1234-123412341234") ==··cont.PubValType.GuidVar, "GuidVar falsch #2");
609 ············Assert.That(0x1234 ==··cont.PubValType.Int16Var, "Int16Var falsch #2");
610 ············Assert.That(0x12341234 ==··cont.PubValType.Int32Var, "Int32Var falsch #2");
611 ············Assert.That(0x143214321 ==··cont.PubValType.Int64Var, "Int64Var falsch #2");
612 ············Assert.That("Teststring" ==··cont.PubValType.StringVar, "StringVar falsch #2");
613 ············Assert.That(0xabc ==··cont.PubValType.Uint16Var, "Uint16Var falsch #2");
614 ············Assert.That(0x12341234 ==··cont.PubValType.Uint32Var, "Uint32Var falsch #2");
615 ············Assert.That(0x143214321 ==··cont.PubValType.Uint64Var, "Uint64Var falsch #2");
616 ············Assert.That(EnumType.zwei ==··cont.PubValType.EnumVar, "EnumVar falsch #2");
617 ············Assert.That(Guid.Empty ==··cont.PubValType.EmptyGuidVar, "EmptyGuidVar falsch #2");
618 ············Assert.That(DateTime.MinValue ==··cont.PubValType.EmptyDateTimeVar, "EmptyDateTimeVar falsch #2");
619 ············Assert.That(cont.PubValType.NullString == null, "Empty String falsch #1");
620
621 ············Assert.That(0x55 ==··cont.EmbeddedType.ByteVar, "ByteVar falsch #3");
622 ············Assert.That(true ==·· cont.EmbeddedType.BoolVar, "BoolVar falsch #3");
623 ············Assert.That(12.34m ==··cont.EmbeddedType.DecVar, "DecVar falsch #3");
624 #if !FIREBIRD && !POSTGRE
625 ············Assert.That(new DateTime(2002, 12, 1, 1, 0, 20) == cont.EmbeddedType.DateTimeVar, "DateTimeVar falsch #2");
626 #else
627 ············Assert.That(new DateTime(2002, 12, 1, 0, 0, 0) == cont.EmbeddedType.DateTimeVar, "DateTimeVar falsch #2");
628 #endif
629 #if SQLITE
630 ············Assert.That( CheckDouble( 12345.123456, cont.PropValType.DoubleVar ), "DoubleVar falsch #1" );
631 ············Assert.That( CheckFloat( 12345.1f, cont.PropValType.FloatVar ), "FloatVar falsch #1" );
632 #else
633 ············Assert.That(12345.123456 ==··cont.EmbeddedType.DoubleVar, "DoubleVar falsch #3");
634 ············Assert.That(12345.1f ==··cont.EmbeddedType.FloatVar, "FloatVar falsch #3");
635 #endif
636 ············Assert.That(new Guid("12341234-1234-1234-1234-123412341234") ==··cont.EmbeddedType.GuidVar, "GuidVar falsch #3");
637 ············Assert.That(0x1234 ==··cont.EmbeddedType.Int16Var, "Int16Var falsch #3");
638 ············Assert.That(0x12341234 ==··cont.EmbeddedType.Int32Var, "Int32Var falsch #3");
639 ············Assert.That(0x143214321 ==··cont.EmbeddedType.Int64Var, "Int64Var falsch #3");
640 ············Assert.That("Teststring" ==··cont.EmbeddedType.StringVar, "StringVar falsch #3");
641 ············Assert.That(0xabc ==··cont.EmbeddedType.Uint16Var, "Uint16Var falsch #3");
642 ············Assert.That(0x12341234 ==··cont.EmbeddedType.Uint32Var, "Uint32Var falsch #3");
643 ············Assert.That(0x143214321 ==··cont.EmbeddedType.Uint64Var, "Uint64Var falsch #3");
644 ············Assert.That(EnumType.drei ==··cont.EmbeddedType.EnumVar, "EnumVar falsch #3");
645 ············Assert.That(Guid.Empty ==··cont.EmbeddedType.EmptyGuidVar, "EmptyGuidVar falsch #3");
646 ············Assert.That(DateTime.MinValue ==··cont.EmbeddedType.EmptyDateTimeVar, "EmptyDateTimeVar falsch #3");
647 ············Assert.That(cont.EmbeddedType.NullString == null, "Empty String falsch #1");
648 ········}
649 ····}
650 }
651