Datei: UnitTestGenerator/UnitTests/MappingUnitTests.cs

Last Commit (6d63e12)

1	//
2	// Copyright (c) 2002-2019 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.Linq;
25	using System.Diagnostics;
26	using System.Collections;
27	using System.Collections.Generic;
28	using NDO;
29	using NDO.Mapping;
30	using NUnit.Framework;
31	using NdoUnitTests;
32
33	namespace MappingUnitTests
34	{
35
36	public class PmFactory
37	{
38	····static PersistenceManager pm;
39	····public static PersistenceManager NewPersistenceManager()
40	····{
41	········if (pm == null)
42	········{
43	pm = new PersistenceManager( @"C:\Projekte\NDO5\UnitTestGenerator\TestGenerator\bin\UnitTests\bin\Debug\NDOMapping. xml") ;
44	········}
45	········else
46	········{
47	············pm.UnloadCache();
48	········}
49	········return pm;
50	····}
51	}
52
53
54	[TestFixture]
55	public class MappingTestAgrDir1NoTblAuto : NDOTest
56	{
57	····PersistenceManager pm;
58	····NDOMapping mapping;
59	····Class ownClass;
60	····Class otherClass;
61	····[SetUp]
62	····public void Setup()
63	····{
64	········this.pm = PmFactory.NewPersistenceManager();
65	········this.mapping = pm.NDOMapping;
66	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1NoTblAutoLeft" );
67	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1NoTblAutoRight" );
68	····}
69	····[Test]
70	····public void HasMappingTable()
71	····{
72	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
73	····}
74	····[Test]
75	····public void HasTypeColumn()
76	····{
77	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
78	····}
79	····[Test]
80	····public void HasTypeCode()
81	····{
82	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
83	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
84	····}
85	}
86
87
88	[TestFixture]
89	public class MappingTestAgrDir1TblAuto : NDOTest
90	{
91	····PersistenceManager pm;
92	····NDOMapping mapping;
93	····Class ownClass;
94	····Class otherClass;
95	····[SetUp]
96	····public void Setup()
97	····{
98	········this.pm = PmFactory.NewPersistenceManager();
99	········this.mapping = pm.NDOMapping;
100	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1TblAutoLeft" );
101	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1TblAutoRight" );
102	····}
103	····[Test]
104	····public void HasMappingTable()
105	····{
106	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
107	····}
108	····[Test]
109	····public void HasTypeColumn()
110	····{
111	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
112	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
113	····}
114	····[Test]
115	····public void HasTypeCode()
116	····{
117	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
118	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
119	····}
120	}
121
122
123	[TestFixture]
124	public class MappingTestAgrBi11NoTblAuto : NDOTest
125	{
126	····PersistenceManager pm;
127	····NDOMapping mapping;
128	····Class ownClass;
129	····Class otherClass;
130	····[SetUp]
131	····public void Setup()
132	····{
133	········this.pm = PmFactory.NewPersistenceManager();
134	········this.mapping = pm.NDOMapping;
135	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11NoTblAutoLeft" );
136	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11NoTblAutoRight" );
137	····}
138	····[Test]
139	····public void HasMappingTable()
140	····{
141	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
142	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
143	····}
144	····[Test]
145	····public void HasTypeColumn()
146	····{
147	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
148	····}
149	····[Test]
150	····public void HasTypeCode()
151	····{
152	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
153	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
154	····}
155	}
156
157
158	[TestFixture]
159	public class MappingTestAgrBi11TblAuto : NDOTest
160	{
161	····PersistenceManager pm;
162	····NDOMapping mapping;
163	····Class ownClass;
164	····Class otherClass;
165	····[SetUp]
166	····public void Setup()
167	····{
168	········this.pm = PmFactory.NewPersistenceManager();
169	········this.mapping = pm.NDOMapping;
170	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11TblAutoLeft" );
171	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11TblAutoRight" );
172	····}
173	····[Test]
174	····public void HasMappingTable()
175	····{
176	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
177	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
178	····}
179	····[Test]
180	····public void HasTypeColumn()
181	····{
182	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
183	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
184	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
185	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
186	····}
187	····[Test]
188	····public void HasTypeCode()
189	····{
190	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
191	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
192	····}
193	}
194
195
196	[TestFixture]
197	public class MappingTestAgrDirnNoTblAuto : NDOTest
198	{
199	····PersistenceManager pm;
200	····NDOMapping mapping;
201	····Class ownClass;
202	····Class otherClass;
203	····[SetUp]
204	····public void Setup()
205	····{
206	········this.pm = PmFactory.NewPersistenceManager();
207	········this.mapping = pm.NDOMapping;
208	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnNoTblAutoLeft" );
209	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnNoTblAutoRight" );
210	····}
211	····[Test]
212	····public void HasMappingTable()
213	····{
214	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
215	····}
216	····[Test]
217	····public void HasTypeColumn()
218	····{
219	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
220	····}
221	····[Test]
222	····public void HasTypeCode()
223	····{
224	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
225	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
226	····}
227	}
228
229
230	[TestFixture]
231	public class MappingTestAgrDirnTblAuto : NDOTest
232	{
233	····PersistenceManager pm;
234	····NDOMapping mapping;
235	····Class ownClass;
236	····Class otherClass;
237	····[SetUp]
238	····public void Setup()
239	····{
240	········this.pm = PmFactory.NewPersistenceManager();
241	········this.mapping = pm.NDOMapping;
242	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnTblAutoLeft" );
243	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnTblAutoRight" );
244	····}
245	····[Test]
246	····public void HasMappingTable()
247	····{
248	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
249	····}
250	····[Test]
251	····public void HasTypeColumn()
252	····{
253	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
254	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
255	····}
256	····[Test]
257	····public void HasTypeCode()
258	····{
259	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
260	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
261	····}
262	}
263
264
265	[TestFixture]
266	public class MappingTestAgrBin1NoTblAuto : NDOTest
267	{
268	····PersistenceManager pm;
269	····NDOMapping mapping;
270	····Class ownClass;
271	····Class otherClass;
272	····[SetUp]
273	····public void Setup()
274	····{
275	········this.pm = PmFactory.NewPersistenceManager();
276	········this.mapping = pm.NDOMapping;
277	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1NoTblAutoLeft" );
278	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1NoTblAutoRight" );
279	····}
280	····[Test]
281	····public void HasMappingTable()
282	····{
283	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
284	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
285	····}
286	····[Test]
287	····public void HasTypeColumn()
288	····{
289	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
290	····}
291	····[Test]
292	····public void HasTypeCode()
293	····{
294	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
295	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
296	····}
297	}
298
299
300	[TestFixture]
301	public class MappingTestAgrBin1TblAuto : NDOTest
302	{
303	····PersistenceManager pm;
304	····NDOMapping mapping;
305	····Class ownClass;
306	····Class otherClass;
307	····[SetUp]
308	····public void Setup()
309	····{
310	········this.pm = PmFactory.NewPersistenceManager();
311	········this.mapping = pm.NDOMapping;
312	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1TblAutoLeft" );
313	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1TblAutoRight" );
314	····}
315	····[Test]
316	····public void HasMappingTable()
317	····{
318	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
319	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
320	····}
321	····[Test]
322	····public void HasTypeColumn()
323	····{
324	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
325	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
326	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
327	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
328	····}
329	····[Test]
330	····public void HasTypeCode()
331	····{
332	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
333	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
334	····}
335	}
336
337
338	[TestFixture]
339	public class MappingTestAgrBi1nNoTblAuto : NDOTest
340	{
341	····PersistenceManager pm;
342	····NDOMapping mapping;
343	····Class ownClass;
344	····Class otherClass;
345	····[SetUp]
346	····public void Setup()
347	····{
348	········this.pm = PmFactory.NewPersistenceManager();
349	········this.mapping = pm.NDOMapping;
350	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nNoTblAutoLeft" );
351	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nNoTblAutoRight" );
352	····}
353	····[Test]
354	····public void HasMappingTable()
355	····{
356	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
357	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
358	····}
359	····[Test]
360	····public void HasTypeColumn()
361	····{
362	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
363	····}
364	····[Test]
365	····public void HasTypeCode()
366	····{
367	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
368	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
369	····}
370	}
371
372
373	[TestFixture]
374	public class MappingTestAgrBi1nTblAuto : NDOTest
375	{
376	····PersistenceManager pm;
377	····NDOMapping mapping;
378	····Class ownClass;
379	····Class otherClass;
380	····[SetUp]
381	····public void Setup()
382	····{
383	········this.pm = PmFactory.NewPersistenceManager();
384	········this.mapping = pm.NDOMapping;
385	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nTblAutoLeft" );
386	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nTblAutoRight" );
387	····}
388	····[Test]
389	····public void HasMappingTable()
390	····{
391	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
392	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
393	····}
394	····[Test]
395	····public void HasTypeColumn()
396	····{
397	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
398	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
399	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
400	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
401	····}
402	····[Test]
403	····public void HasTypeCode()
404	····{
405	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
406	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
407	····}
408	}
409
410
411	[TestFixture]
412	public class MappingTestAgrBinnTblAuto : NDOTest
413	{
414	····PersistenceManager pm;
415	····NDOMapping mapping;
416	····Class ownClass;
417	····Class otherClass;
418	····[SetUp]
419	····public void Setup()
420	····{
421	········this.pm = PmFactory.NewPersistenceManager();
422	········this.mapping = pm.NDOMapping;
423	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnTblAutoLeft" );
424	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnTblAutoRight" );
425	····}
426	····[Test]
427	····public void HasMappingTable()
428	····{
429	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
430	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
431	····}
432	····[Test]
433	····public void HasTypeColumn()
434	····{
435	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
436	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
437	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
438	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
439	····}
440	····[Test]
441	····public void HasTypeCode()
442	····{
443	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
444	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
445	····}
446	}
447
448
449	[TestFixture]
450	public class MappingTestCmpDir1NoTblAuto : NDOTest
451	{
452	····PersistenceManager pm;
453	····NDOMapping mapping;
454	····Class ownClass;
455	····Class otherClass;
456	····[SetUp]
457	····public void Setup()
458	····{
459	········this.pm = PmFactory.NewPersistenceManager();
460	········this.mapping = pm.NDOMapping;
461	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1NoTblAutoLeft" );
462	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1NoTblAutoRight" );
463	····}
464	····[Test]
465	····public void HasMappingTable()
466	····{
467	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
468	····}
469	····[Test]
470	····public void HasTypeColumn()
471	····{
472	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
473	····}
474	····[Test]
475	····public void HasTypeCode()
476	····{
477	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
478	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
479	····}
480	}
481
482
483	[TestFixture]
484	public class MappingTestCmpDir1TblAuto : NDOTest
485	{
486	····PersistenceManager pm;
487	····NDOMapping mapping;
488	····Class ownClass;
489	····Class otherClass;
490	····[SetUp]
491	····public void Setup()
492	····{
493	········this.pm = PmFactory.NewPersistenceManager();
494	········this.mapping = pm.NDOMapping;
495	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1TblAutoLeft" );
496	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1TblAutoRight" );
497	····}
498	····[Test]
499	····public void HasMappingTable()
500	····{
501	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
502	····}
503	····[Test]
504	····public void HasTypeColumn()
505	····{
506	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
507	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
508	····}
509	····[Test]
510	····public void HasTypeCode()
511	····{
512	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
513	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
514	····}
515	}
516
517
518	[TestFixture]
519	public class MappingTestCmpBi11NoTblAuto : NDOTest
520	{
521	····PersistenceManager pm;
522	····NDOMapping mapping;
523	····Class ownClass;
524	····Class otherClass;
525	····[SetUp]
526	····public void Setup()
527	····{
528	········this.pm = PmFactory.NewPersistenceManager();
529	········this.mapping = pm.NDOMapping;
530	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11NoTblAutoLeft" );
531	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11NoTblAutoRight" );
532	····}
533	····[Test]
534	····public void HasMappingTable()
535	····{
536	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
537	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
538	····}
539	····[Test]
540	····public void HasTypeColumn()
541	····{
542	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
543	····}
544	····[Test]
545	····public void HasTypeCode()
546	····{
547	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
548	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
549	····}
550	}
551
552
553	[TestFixture]
554	public class MappingTestCmpBi11TblAuto : NDOTest
555	{
556	····PersistenceManager pm;
557	····NDOMapping mapping;
558	····Class ownClass;
559	····Class otherClass;
560	····[SetUp]
561	····public void Setup()
562	····{
563	········this.pm = PmFactory.NewPersistenceManager();
564	········this.mapping = pm.NDOMapping;
565	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11TblAutoLeft" );
566	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11TblAutoRight" );
567	····}
568	····[Test]
569	····public void HasMappingTable()
570	····{
571	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
572	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
573	····}
574	····[Test]
575	····public void HasTypeColumn()
576	····{
577	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
578	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
579	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
580	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
581	····}
582	····[Test]
583	····public void HasTypeCode()
584	····{
585	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
586	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
587	····}
588	}
589
590
591	[TestFixture]
592	public class MappingTestCmpDirnNoTblAuto : NDOTest
593	{
594	····PersistenceManager pm;
595	····NDOMapping mapping;
596	····Class ownClass;
597	····Class otherClass;
598	····[SetUp]
599	····public void Setup()
600	····{
601	········this.pm = PmFactory.NewPersistenceManager();
602	········this.mapping = pm.NDOMapping;
603	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnNoTblAutoLeft" );
604	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnNoTblAutoRight" );
605	····}
606	····[Test]
607	····public void HasMappingTable()
608	····{
609	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
610	····}
611	····[Test]
612	····public void HasTypeColumn()
613	····{
614	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
615	····}
616	····[Test]
617	····public void HasTypeCode()
618	····{
619	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
620	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
621	····}
622	}
623
624
625	[TestFixture]
626	public class MappingTestCmpDirnTblAuto : NDOTest
627	{
628	····PersistenceManager pm;
629	····NDOMapping mapping;
630	····Class ownClass;
631	····Class otherClass;
632	····[SetUp]
633	····public void Setup()
634	····{
635	········this.pm = PmFactory.NewPersistenceManager();
636	········this.mapping = pm.NDOMapping;
637	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnTblAutoLeft" );
638	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnTblAutoRight" );
639	····}
640	····[Test]
641	····public void HasMappingTable()
642	····{
643	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
644	····}
645	····[Test]
646	····public void HasTypeColumn()
647	····{
648	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
649	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
650	····}
651	····[Test]
652	····public void HasTypeCode()
653	····{
654	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
655	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
656	····}
657	}
658
659
660	[TestFixture]
661	public class MappingTestCmpBin1NoTblAuto : NDOTest
662	{
663	····PersistenceManager pm;
664	····NDOMapping mapping;
665	····Class ownClass;
666	····Class otherClass;
667	····[SetUp]
668	····public void Setup()
669	····{
670	········this.pm = PmFactory.NewPersistenceManager();
671	········this.mapping = pm.NDOMapping;
672	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1NoTblAutoLeft" );
673	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1NoTblAutoRight" );
674	····}
675	····[Test]
676	····public void HasMappingTable()
677	····{
678	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
679	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
680	····}
681	····[Test]
682	····public void HasTypeColumn()
683	····{
684	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
685	····}
686	····[Test]
687	····public void HasTypeCode()
688	····{
689	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
690	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
691	····}
692	}
693
694
695	[TestFixture]
696	public class MappingTestCmpBin1TblAuto : NDOTest
697	{
698	····PersistenceManager pm;
699	····NDOMapping mapping;
700	····Class ownClass;
701	····Class otherClass;
702	····[SetUp]
703	····public void Setup()
704	····{
705	········this.pm = PmFactory.NewPersistenceManager();
706	········this.mapping = pm.NDOMapping;
707	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1TblAutoLeft" );
708	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1TblAutoRight" );
709	····}
710	····[Test]
711	····public void HasMappingTable()
712	····{
713	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
714	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
715	····}
716	····[Test]
717	····public void HasTypeColumn()
718	····{
719	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
720	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
721	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
722	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
723	····}
724	····[Test]
725	····public void HasTypeCode()
726	····{
727	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
728	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
729	····}
730	}
731
732
733	[TestFixture]
734	public class MappingTestCmpBi1nNoTblAuto : NDOTest
735	{
736	····PersistenceManager pm;
737	····NDOMapping mapping;
738	····Class ownClass;
739	····Class otherClass;
740	····[SetUp]
741	····public void Setup()
742	····{
743	········this.pm = PmFactory.NewPersistenceManager();
744	········this.mapping = pm.NDOMapping;
745	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nNoTblAutoLeft" );
746	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nNoTblAutoRight" );
747	····}
748	····[Test]
749	····public void HasMappingTable()
750	····{
751	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
752	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
753	····}
754	····[Test]
755	····public void HasTypeColumn()
756	····{
757	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
758	····}
759	····[Test]
760	····public void HasTypeCode()
761	····{
762	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
763	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
764	····}
765	}
766
767
768	[TestFixture]
769	public class MappingTestCmpBi1nTblAuto : NDOTest
770	{
771	····PersistenceManager pm;
772	····NDOMapping mapping;
773	····Class ownClass;
774	····Class otherClass;
775	····[SetUp]
776	····public void Setup()
777	····{
778	········this.pm = PmFactory.NewPersistenceManager();
779	········this.mapping = pm.NDOMapping;
780	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nTblAutoLeft" );
781	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nTblAutoRight" );
782	····}
783	····[Test]
784	····public void HasMappingTable()
785	····{
786	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
787	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
788	····}
789	····[Test]
790	····public void HasTypeColumn()
791	····{
792	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
793	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
794	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
795	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
796	····}
797	····[Test]
798	····public void HasTypeCode()
799	····{
800	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
801	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
802	····}
803	}
804
805
806	[TestFixture]
807	public class MappingTestCmpBinnTblAuto : NDOTest
808	{
809	····PersistenceManager pm;
810	····NDOMapping mapping;
811	····Class ownClass;
812	····Class otherClass;
813	····[SetUp]
814	····public void Setup()
815	····{
816	········this.pm = PmFactory.NewPersistenceManager();
817	········this.mapping = pm.NDOMapping;
818	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnTblAutoLeft" );
819	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnTblAutoRight" );
820	····}
821	····[Test]
822	····public void HasMappingTable()
823	····{
824	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
825	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
826	····}
827	····[Test]
828	····public void HasTypeColumn()
829	····{
830	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
831	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
832	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
833	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
834	····}
835	····[Test]
836	····public void HasTypeCode()
837	····{
838	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
839	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
840	····}
841	}
842
843
844	[TestFixture]
845	public class MappingTestAgrDir1OwnpconNoTblAuto : NDOTest
846	{
847	····PersistenceManager pm;
848	····NDOMapping mapping;
849	····Class ownClass;
850	····Class otherClass;
851	····Class ownDerivedClass;
852	····[SetUp]
853	····public void Setup()
854	····{
855	········this.pm = PmFactory.NewPersistenceManager();
856	········this.mapping = pm.NDOMapping;
857	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconNoTblAutoLeftBase" );
858	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconNoTblAutoRight" );
859	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconNoTblAutoLeftDerived" );
860	····}
861	····[Test]
862	····public void HasMappingTable()
863	····{
864	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
865	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
866	····}
867	····[Test]
868	····public void HasTypeColumn()
869	····{
870	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
871	····}
872	····[Test]
873	····public void HasTypeCode()
874	····{
875	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
876	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
877	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
878	····}
879	}
880
881
882	[TestFixture]
883	public class MappingTestAgrDir1OwnpconTblAuto : NDOTest
884	{
885	····PersistenceManager pm;
886	····NDOMapping mapping;
887	····Class ownClass;
888	····Class otherClass;
889	····Class ownDerivedClass;
890	····[SetUp]
891	····public void Setup()
892	····{
893	········this.pm = PmFactory.NewPersistenceManager();
894	········this.mapping = pm.NDOMapping;
895	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconTblAutoLeftBase" );
896	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconTblAutoRight" );
897	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconTblAutoLeftDerived" );
898	····}
899	····[Test]
900	····public void HasMappingTable()
901	····{
902	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
903	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
904	····}
905	····[Test]
906	····public void HasTypeColumn()
907	····{
908	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
909	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
910	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
911	····}
912	····[Test]
913	····public void HasTypeCode()
914	····{
915	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
916	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
917	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
918	····}
919	}
920
921
922	[TestFixture]
923	public class MappingTestAgrBi11OwnpconNoTblAuto : NDOTest
924	{
925	····PersistenceManager pm;
926	····NDOMapping mapping;
927	····Class ownClass;
928	····Class otherClass;
929	····Class ownDerivedClass;
930	····[SetUp]
931	····public void Setup()
932	····{
933	········this.pm = PmFactory.NewPersistenceManager();
934	········this.mapping = pm.NDOMapping;
935	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconNoTblAutoLeftBase" );
936	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconNoTblAutoRight" );
937	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconNoTblAutoLeftDerived" );
938	····}
939	····[Test]
940	····public void HasMappingTable()
941	····{
942	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
943	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
944	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
945	····}
946	····[Test]
947	····public void HasTypeColumn()
948	····{
949	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
950	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #10");
951	····}
952	····[Test]
953	····public void HasTypeCode()
954	····{
955	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
956	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
957	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
958	····}
959	}
960
961
962	[TestFixture]
963	public class MappingTestAgrBi11OwnpconTblAuto : NDOTest
964	{
965	····PersistenceManager pm;
966	····NDOMapping mapping;
967	····Class ownClass;
968	····Class otherClass;
969	····Class ownDerivedClass;
970	····[SetUp]
971	····public void Setup()
972	····{
973	········this.pm = PmFactory.NewPersistenceManager();
974	········this.mapping = pm.NDOMapping;
975	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconTblAutoLeftBase" );
976	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconTblAutoRight" );
977	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconTblAutoLeftDerived" );
978	····}
979	····[Test]
980	····public void HasMappingTable()
981	····{
982	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
983	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
984	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
985	····}
986	····[Test]
987	····public void HasTypeColumn()
988	····{
989	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
990	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
991	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
992	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
993	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
994	····}
995	····[Test]
996	····public void HasTypeCode()
997	····{
998	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
999	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1000	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1001	····}
1002	}
1003
1004
1005	[TestFixture]
1006	public class MappingTestAgrDirnOwnpconNoTblAuto : NDOTest
1007	{
1008	····PersistenceManager pm;
1009	····NDOMapping mapping;
1010	····Class ownClass;
1011	····Class otherClass;
1012	····Class ownDerivedClass;
1013	····[SetUp]
1014	····public void Setup()
1015	····{
1016	········this.pm = PmFactory.NewPersistenceManager();
1017	········this.mapping = pm.NDOMapping;
1018	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconNoTblAutoLeftBase" );
1019	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconNoTblAutoRight" );
1020	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconNoTblAutoLeftDerived" );
1021	····}
1022	····[Test]
1023	····public void HasMappingTable()
1024	····{
1025	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
1026	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
1027	····}
1028	····[Test]
1029	····public void HasTypeColumn()
1030	····{
1031	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
1032	····}
1033	····[Test]
1034	····public void HasTypeCode()
1035	····{
1036	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1037	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1038	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1039	····}
1040	}
1041
1042
1043	[TestFixture]
1044	public class MappingTestAgrDirnOwnpconTblAuto : NDOTest
1045	{
1046	····PersistenceManager pm;
1047	····NDOMapping mapping;
1048	····Class ownClass;
1049	····Class otherClass;
1050	····Class ownDerivedClass;
1051	····[SetUp]
1052	····public void Setup()
1053	····{
1054	········this.pm = PmFactory.NewPersistenceManager();
1055	········this.mapping = pm.NDOMapping;
1056	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconTblAutoLeftBase" );
1057	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconTblAutoRight" );
1058	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconTblAutoLeftDerived" );
1059	····}
1060	····[Test]
1061	····public void HasMappingTable()
1062	····{
1063	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
1064	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
1065	····}
1066	····[Test]
1067	····public void HasTypeColumn()
1068	····{
1069	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
1070	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
1071	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
1072	····}
1073	····[Test]
1074	····public void HasTypeCode()
1075	····{
1076	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1077	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1078	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1079	····}
1080	}
1081
1082
1083	[TestFixture]
1084	public class MappingTestAgrBin1OwnpconNoTblAuto : NDOTest
1085	{
1086	····PersistenceManager pm;
1087	····NDOMapping mapping;
1088	····Class ownClass;
1089	····Class otherClass;
1090	····Class ownDerivedClass;
1091	····[SetUp]
1092	····public void Setup()
1093	····{
1094	········this.pm = PmFactory.NewPersistenceManager();
1095	········this.mapping = pm.NDOMapping;
1096	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconNoTblAutoLeftBase" );
1097	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconNoTblAutoRight" );
1098	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconNoTblAutoLeftDerived" );
1099	····}
1100	····[Test]
1101	····public void HasMappingTable()
1102	····{
1103	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
1104	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
1105	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
1106	····}
1107	····[Test]
1108	····public void HasTypeColumn()
1109	····{
1110	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
1111	····}
1112	····[Test]
1113	····public void HasTypeCode()
1114	····{
1115	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1116	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1117	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1118	····}
1119	}
1120
1121
1122	[TestFixture]
1123	public class MappingTestAgrBin1OwnpconTblAuto : NDOTest
1124	{
1125	····PersistenceManager pm;
1126	····NDOMapping mapping;
1127	····Class ownClass;
1128	····Class otherClass;
1129	····Class ownDerivedClass;
1130	····[SetUp]
1131	····public void Setup()
1132	····{
1133	········this.pm = PmFactory.NewPersistenceManager();
1134	········this.mapping = pm.NDOMapping;
1135	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconTblAutoLeftBase" );
1136	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconTblAutoRight" );
1137	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconTblAutoLeftDerived" );
1138	····}
1139	····[Test]
1140	····public void HasMappingTable()
1141	····{
1142	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
1143	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
1144	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
1145	····}
1146	····[Test]
1147	····public void HasTypeColumn()
1148	····{
1149	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
1150	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
1151	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
1152	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
1153	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
1154	····}
1155	····[Test]
1156	····public void HasTypeCode()
1157	····{
1158	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1159	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1160	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1161	····}
1162	}
1163
1164
1165	[TestFixture]
1166	public class MappingTestAgrBi1nOwnpconTblAuto : NDOTest
1167	{
1168	····PersistenceManager pm;
1169	····NDOMapping mapping;
1170	····Class ownClass;
1171	····Class otherClass;
1172	····Class ownDerivedClass;
1173	····[SetUp]
1174	····public void Setup()
1175	····{
1176	········this.pm = PmFactory.NewPersistenceManager();
1177	········this.mapping = pm.NDOMapping;
1178	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconTblAutoLeftBase" );
1179	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconTblAutoRight" );
1180	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconTblAutoLeftDerived" );
1181	····}
1182	····[Test]
1183	····public void HasMappingTable()
1184	····{
1185	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
1186	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
1187	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
1188	····}
1189	····[Test]
1190	····public void HasTypeColumn()
1191	····{
1192	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
1193	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
1194	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
1195	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
1196	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
1197	····}
1198	····[Test]
1199	····public void HasTypeCode()
1200	····{
1201	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1202	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1203	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1204	····}
1205	}
1206
1207
1208	[TestFixture]
1209	public class MappingTestAgrBinnOwnpconTblAuto : NDOTest
1210	{
1211	····PersistenceManager pm;
1212	····NDOMapping mapping;
1213	····Class ownClass;
1214	····Class otherClass;
1215	····Class ownDerivedClass;
1216	····[SetUp]
1217	····public void Setup()
1218	····{
1219	········this.pm = PmFactory.NewPersistenceManager();
1220	········this.mapping = pm.NDOMapping;
1221	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconTblAutoLeftBase" );
1222	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconTblAutoRight" );
1223	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconTblAutoLeftDerived" );
1224	····}
1225	····[Test]
1226	····public void HasMappingTable()
1227	····{
1228	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
1229	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
1230	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
1231	····}
1232	····[Test]
1233	····public void HasTypeColumn()
1234	····{
1235	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
1236	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
1237	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
1238	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
1239	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
1240	····}
1241	····[Test]
1242	····public void HasTypeCode()
1243	····{
1244	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1245	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1246	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1247	····}
1248	}
1249
1250
1251	[TestFixture]
1252	public class MappingTestCmpDir1OwnpconNoTblAuto : NDOTest
1253	{
1254	····PersistenceManager pm;
1255	····NDOMapping mapping;
1256	····Class ownClass;
1257	····Class otherClass;
1258	····Class ownDerivedClass;
1259	····[SetUp]
1260	····public void Setup()
1261	····{
1262	········this.pm = PmFactory.NewPersistenceManager();
1263	········this.mapping = pm.NDOMapping;
1264	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconNoTblAutoLeftBase" );
1265	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconNoTblAutoRight" );
1266	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconNoTblAutoLeftDerived" );
1267	····}
1268	····[Test]
1269	····public void HasMappingTable()
1270	····{
1271	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
1272	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
1273	····}
1274	····[Test]
1275	····public void HasTypeColumn()
1276	····{
1277	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
1278	····}
1279	····[Test]
1280	····public void HasTypeCode()
1281	····{
1282	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1283	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1284	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1285	····}
1286	}
1287
1288
1289	[TestFixture]
1290	public class MappingTestCmpDir1OwnpconTblAuto : NDOTest
1291	{
1292	····PersistenceManager pm;
1293	····NDOMapping mapping;
1294	····Class ownClass;
1295	····Class otherClass;
1296	····Class ownDerivedClass;
1297	····[SetUp]
1298	····public void Setup()
1299	····{
1300	········this.pm = PmFactory.NewPersistenceManager();
1301	········this.mapping = pm.NDOMapping;
1302	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconTblAutoLeftBase" );
1303	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconTblAutoRight" );
1304	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconTblAutoLeftDerived" );
1305	····}
1306	····[Test]
1307	····public void HasMappingTable()
1308	····{
1309	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
1310	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
1311	····}
1312	····[Test]
1313	····public void HasTypeColumn()
1314	····{
1315	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
1316	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
1317	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
1318	····}
1319	····[Test]
1320	····public void HasTypeCode()
1321	····{
1322	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1323	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1324	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1325	····}
1326	}
1327
1328
1329	[TestFixture]
1330	public class MappingTestCmpBi11OwnpconNoTblAuto : NDOTest
1331	{
1332	····PersistenceManager pm;
1333	····NDOMapping mapping;
1334	····Class ownClass;
1335	····Class otherClass;
1336	····Class ownDerivedClass;
1337	····[SetUp]
1338	····public void Setup()
1339	····{
1340	········this.pm = PmFactory.NewPersistenceManager();
1341	········this.mapping = pm.NDOMapping;
1342	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconNoTblAutoLeftBase" );
1343	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconNoTblAutoRight" );
1344	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconNoTblAutoLeftDerived" );
1345	····}
1346	····[Test]
1347	····public void HasMappingTable()
1348	····{
1349	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
1350	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
1351	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
1352	····}
1353	····[Test]
1354	····public void HasTypeColumn()
1355	····{
1356	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
1357	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #10");
1358	····}
1359	····[Test]
1360	····public void HasTypeCode()
1361	····{
1362	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1363	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1364	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1365	····}
1366	}
1367
1368
1369	[TestFixture]
1370	public class MappingTestCmpBi11OwnpconTblAuto : NDOTest
1371	{
1372	····PersistenceManager pm;
1373	····NDOMapping mapping;
1374	····Class ownClass;
1375	····Class otherClass;
1376	····Class ownDerivedClass;
1377	····[SetUp]
1378	····public void Setup()
1379	····{
1380	········this.pm = PmFactory.NewPersistenceManager();
1381	········this.mapping = pm.NDOMapping;
1382	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconTblAutoLeftBase" );
1383	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconTblAutoRight" );
1384	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconTblAutoLeftDerived" );
1385	····}
1386	····[Test]
1387	····public void HasMappingTable()
1388	····{
1389	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
1390	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
1391	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
1392	····}
1393	····[Test]
1394	····public void HasTypeColumn()
1395	····{
1396	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
1397	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
1398	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
1399	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
1400	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
1401	····}
1402	····[Test]
1403	····public void HasTypeCode()
1404	····{
1405	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1406	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1407	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1408	····}
1409	}
1410
1411
1412	[TestFixture]
1413	public class MappingTestCmpDirnOwnpconNoTblAuto : NDOTest
1414	{
1415	····PersistenceManager pm;
1416	····NDOMapping mapping;
1417	····Class ownClass;
1418	····Class otherClass;
1419	····Class ownDerivedClass;
1420	····[SetUp]
1421	····public void Setup()
1422	····{
1423	········this.pm = PmFactory.NewPersistenceManager();
1424	········this.mapping = pm.NDOMapping;
1425	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconNoTblAutoLeftBase" );
1426	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconNoTblAutoRight" );
1427	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconNoTblAutoLeftDerived" );
1428	····}
1429	····[Test]
1430	····public void HasMappingTable()
1431	····{
1432	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
1433	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
1434	····}
1435	····[Test]
1436	····public void HasTypeColumn()
1437	····{
1438	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
1439	····}
1440	····[Test]
1441	····public void HasTypeCode()
1442	····{
1443	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1444	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1445	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1446	····}
1447	}
1448
1449
1450	[TestFixture]
1451	public class MappingTestCmpDirnOwnpconTblAuto : NDOTest
1452	{
1453	····PersistenceManager pm;
1454	····NDOMapping mapping;
1455	····Class ownClass;
1456	····Class otherClass;
1457	····Class ownDerivedClass;
1458	····[SetUp]
1459	····public void Setup()
1460	····{
1461	········this.pm = PmFactory.NewPersistenceManager();
1462	········this.mapping = pm.NDOMapping;
1463	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconTblAutoLeftBase" );
1464	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconTblAutoRight" );
1465	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconTblAutoLeftDerived" );
1466	····}
1467	····[Test]
1468	····public void HasMappingTable()
1469	····{
1470	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
1471	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
1472	····}
1473	····[Test]
1474	····public void HasTypeColumn()
1475	····{
1476	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
1477	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
1478	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
1479	····}
1480	····[Test]
1481	····public void HasTypeCode()
1482	····{
1483	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1484	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1485	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1486	····}
1487	}
1488
1489
1490	[TestFixture]
1491	public class MappingTestCmpBin1OwnpconNoTblAuto : NDOTest
1492	{
1493	····PersistenceManager pm;
1494	····NDOMapping mapping;
1495	····Class ownClass;
1496	····Class otherClass;
1497	····Class ownDerivedClass;
1498	····[SetUp]
1499	····public void Setup()
1500	····{
1501	········this.pm = PmFactory.NewPersistenceManager();
1502	········this.mapping = pm.NDOMapping;
1503	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconNoTblAutoLeftBase" );
1504	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconNoTblAutoRight" );
1505	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconNoTblAutoLeftDerived" );
1506	····}
1507	····[Test]
1508	····public void HasMappingTable()
1509	····{
1510	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
1511	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
1512	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
1513	····}
1514	····[Test]
1515	····public void HasTypeColumn()
1516	····{
1517	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
1518	····}
1519	····[Test]
1520	····public void HasTypeCode()
1521	····{
1522	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1523	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1524	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1525	····}
1526	}
1527
1528
1529	[TestFixture]
1530	public class MappingTestCmpBin1OwnpconTblAuto : NDOTest
1531	{
1532	····PersistenceManager pm;
1533	····NDOMapping mapping;
1534	····Class ownClass;
1535	····Class otherClass;
1536	····Class ownDerivedClass;
1537	····[SetUp]
1538	····public void Setup()
1539	····{
1540	········this.pm = PmFactory.NewPersistenceManager();
1541	········this.mapping = pm.NDOMapping;
1542	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconTblAutoLeftBase" );
1543	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconTblAutoRight" );
1544	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconTblAutoLeftDerived" );
1545	····}
1546	····[Test]
1547	····public void HasMappingTable()
1548	····{
1549	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
1550	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
1551	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
1552	····}
1553	····[Test]
1554	····public void HasTypeColumn()
1555	····{
1556	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
1557	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
1558	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
1559	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
1560	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
1561	····}
1562	····[Test]
1563	····public void HasTypeCode()
1564	····{
1565	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1566	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1567	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1568	····}
1569	}
1570
1571
1572	[TestFixture]
1573	public class MappingTestCmpBi1nOwnpconTblAuto : NDOTest
1574	{
1575	····PersistenceManager pm;
1576	····NDOMapping mapping;
1577	····Class ownClass;
1578	····Class otherClass;
1579	····Class ownDerivedClass;
1580	····[SetUp]
1581	····public void Setup()
1582	····{
1583	········this.pm = PmFactory.NewPersistenceManager();
1584	········this.mapping = pm.NDOMapping;
1585	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconTblAutoLeftBase" );
1586	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconTblAutoRight" );
1587	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconTblAutoLeftDerived" );
1588	····}
1589	····[Test]
1590	····public void HasMappingTable()
1591	····{
1592	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
1593	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
1594	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
1595	····}
1596	····[Test]
1597	····public void HasTypeColumn()
1598	····{
1599	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
1600	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
1601	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
1602	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
1603	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
1604	····}
1605	····[Test]
1606	····public void HasTypeCode()
1607	····{
1608	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1609	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1610	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1611	····}
1612	}
1613
1614
1615	[TestFixture]
1616	public class MappingTestCmpBinnOwnpconTblAuto : NDOTest
1617	{
1618	····PersistenceManager pm;
1619	····NDOMapping mapping;
1620	····Class ownClass;
1621	····Class otherClass;
1622	····Class ownDerivedClass;
1623	····[SetUp]
1624	····public void Setup()
1625	····{
1626	········this.pm = PmFactory.NewPersistenceManager();
1627	········this.mapping = pm.NDOMapping;
1628	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconTblAutoLeftBase" );
1629	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconTblAutoRight" );
1630	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconTblAutoLeftDerived" );
1631	····}
1632	····[Test]
1633	····public void HasMappingTable()
1634	····{
1635	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
1636	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
1637	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
1638	····}
1639	····[Test]
1640	····public void HasTypeColumn()
1641	····{
1642	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
1643	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
1644	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
1645	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
1646	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
1647	····}
1648	····[Test]
1649	····public void HasTypeCode()
1650	····{
1651	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1652	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1653	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1654	····}
1655	}
1656
1657
1658	[TestFixture]
1659	public class MappingTestAgrDir1OthpconNoTblAuto : NDOTest
1660	{
1661	····PersistenceManager pm;
1662	····NDOMapping mapping;
1663	····Class ownClass;
1664	····Class otherClass;
1665	····Class otherDerivedClass;
1666	····[SetUp]
1667	····public void Setup()
1668	····{
1669	········this.pm = PmFactory.NewPersistenceManager();
1670	········this.mapping = pm.NDOMapping;
1671	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconNoTblAutoLeft" );
1672	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconNoTblAutoRightBase" );
1673	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconNoTblAutoRightDerived" );
1674	····}
1675	····[Test]
1676	····public void HasMappingTable()
1677	····{
1678	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
1679	····}
1680	····[Test]
1681	····public void HasTypeColumn()
1682	····{
1683	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
1684	····}
1685	····[Test]
1686	····public void HasTypeCode()
1687	····{
1688	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1689	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1690	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
1691	····}
1692	}
1693
1694
1695	[TestFixture]
1696	public class MappingTestAgrDir1OthpconTblAuto : NDOTest
1697	{
1698	····PersistenceManager pm;
1699	····NDOMapping mapping;
1700	····Class ownClass;
1701	····Class otherClass;
1702	····Class otherDerivedClass;
1703	····[SetUp]
1704	····public void Setup()
1705	····{
1706	········this.pm = PmFactory.NewPersistenceManager();
1707	········this.mapping = pm.NDOMapping;
1708	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconTblAutoLeft" );
1709	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconTblAutoRightBase" );
1710	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconTblAutoRightDerived" );
1711	····}
1712	····[Test]
1713	····public void HasMappingTable()
1714	····{
1715	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
1716	····}
1717	····[Test]
1718	····public void HasTypeColumn()
1719	····{
1720	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
1721	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
1722	····}
1723	····[Test]
1724	····public void HasTypeCode()
1725	····{
1726	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1727	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1728	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
1729	····}
1730	}
1731
1732
1733	[TestFixture]
1734	public class MappingTestAgrBi11OthpconNoTblAuto : NDOTest
1735	{
1736	····PersistenceManager pm;
1737	····NDOMapping mapping;
1738	····Class ownClass;
1739	····Class otherClass;
1740	····Class otherDerivedClass;
1741	····[SetUp]
1742	····public void Setup()
1743	····{
1744	········this.pm = PmFactory.NewPersistenceManager();
1745	········this.mapping = pm.NDOMapping;
1746	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconNoTblAutoLeft" );
1747	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconNoTblAutoRightBase" );
1748	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconNoTblAutoRightDerived" );
1749	····}
1750	····[Test]
1751	····public void HasMappingTable()
1752	····{
1753	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
1754	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
1755	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
1756	····}
1757	····[Test]
1758	····public void HasTypeColumn()
1759	····{
1760	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
1761	····}
1762	····[Test]
1763	····public void HasTypeCode()
1764	····{
1765	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1766	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1767	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
1768	····}
1769	}
1770
1771
1772	[TestFixture]
1773	public class MappingTestAgrBi11OthpconTblAuto : NDOTest
1774	{
1775	····PersistenceManager pm;
1776	····NDOMapping mapping;
1777	····Class ownClass;
1778	····Class otherClass;
1779	····Class otherDerivedClass;
1780	····[SetUp]
1781	····public void Setup()
1782	····{
1783	········this.pm = PmFactory.NewPersistenceManager();
1784	········this.mapping = pm.NDOMapping;
1785	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconTblAutoLeft" );
1786	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconTblAutoRightBase" );
1787	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconTblAutoRightDerived" );
1788	····}
1789	····[Test]
1790	····public void HasMappingTable()
1791	····{
1792	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
1793	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
1794	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
1795	····}
1796	····[Test]
1797	····public void HasTypeColumn()
1798	····{
1799	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
1800	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
1801	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
1802	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
1803	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
1804	····}
1805	····[Test]
1806	····public void HasTypeCode()
1807	····{
1808	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1809	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1810	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
1811	····}
1812	}
1813
1814
1815	[TestFixture]
1816	public class MappingTestAgrDirnOthpconTblAuto : NDOTest
1817	{
1818	····PersistenceManager pm;
1819	····NDOMapping mapping;
1820	····Class ownClass;
1821	····Class otherClass;
1822	····Class otherDerivedClass;
1823	····[SetUp]
1824	····public void Setup()
1825	····{
1826	········this.pm = PmFactory.NewPersistenceManager();
1827	········this.mapping = pm.NDOMapping;
1828	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpconTblAutoLeft" );
1829	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpconTblAutoRightBase" );
1830	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpconTblAutoRightDerived" );
1831	····}
1832	····[Test]
1833	····public void HasMappingTable()
1834	····{
1835	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
1836	····}
1837	····[Test]
1838	····public void HasTypeColumn()
1839	····{
1840	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
1841	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
1842	····}
1843	····[Test]
1844	····public void HasTypeCode()
1845	····{
1846	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1847	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1848	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
1849	····}
1850	}
1851
1852
1853	[TestFixture]
1854	public class MappingTestAgrBin1OthpconTblAuto : NDOTest
1855	{
1856	····PersistenceManager pm;
1857	····NDOMapping mapping;
1858	····Class ownClass;
1859	····Class otherClass;
1860	····Class otherDerivedClass;
1861	····[SetUp]
1862	····public void Setup()
1863	····{
1864	········this.pm = PmFactory.NewPersistenceManager();
1865	········this.mapping = pm.NDOMapping;
1866	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpconTblAutoLeft" );
1867	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpconTblAutoRightBase" );
1868	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpconTblAutoRightDerived" );
1869	····}
1870	····[Test]
1871	····public void HasMappingTable()
1872	····{
1873	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
1874	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
1875	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
1876	····}
1877	····[Test]
1878	····public void HasTypeColumn()
1879	····{
1880	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
1881	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
1882	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
1883	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
1884	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
1885	····}
1886	····[Test]
1887	····public void HasTypeCode()
1888	····{
1889	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1890	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1891	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
1892	····}
1893	}
1894
1895
1896	[TestFixture]
1897	public class MappingTestAgrBi1nOthpconNoTblAuto : NDOTest
1898	{
1899	····PersistenceManager pm;
1900	····NDOMapping mapping;
1901	····Class ownClass;
1902	····Class otherClass;
1903	····Class otherDerivedClass;
1904	····[SetUp]
1905	····public void Setup()
1906	····{
1907	········this.pm = PmFactory.NewPersistenceManager();
1908	········this.mapping = pm.NDOMapping;
1909	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconNoTblAutoLeft" );
1910	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconNoTblAutoRightBase" );
1911	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconNoTblAutoRightDerived" );
1912	····}
1913	····[Test]
1914	····public void HasMappingTable()
1915	····{
1916	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
1917	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
1918	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
1919	····}
1920	····[Test]
1921	····public void HasTypeColumn()
1922	····{
1923	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
1924	····}
1925	····[Test]
1926	····public void HasTypeCode()
1927	····{
1928	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1929	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1930	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
1931	····}
1932	}
1933
1934
1935	[TestFixture]
1936	public class MappingTestAgrBi1nOthpconTblAuto : NDOTest
1937	{
1938	····PersistenceManager pm;
1939	····NDOMapping mapping;
1940	····Class ownClass;
1941	····Class otherClass;
1942	····Class otherDerivedClass;
1943	····[SetUp]
1944	····public void Setup()
1945	····{
1946	········this.pm = PmFactory.NewPersistenceManager();
1947	········this.mapping = pm.NDOMapping;
1948	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconTblAutoLeft" );
1949	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconTblAutoRightBase" );
1950	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconTblAutoRightDerived" );
1951	····}
1952	····[Test]
1953	····public void HasMappingTable()
1954	····{
1955	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
1956	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
1957	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
1958	····}
1959	····[Test]
1960	····public void HasTypeColumn()
1961	····{
1962	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
1963	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
1964	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
1965	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
1966	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
1967	····}
1968	····[Test]
1969	····public void HasTypeCode()
1970	····{
1971	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1972	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1973	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
1974	····}
1975	}
1976
1977
1978	[TestFixture]
1979	public class MappingTestAgrBinnOthpconTblAuto : NDOTest
1980	{
1981	····PersistenceManager pm;
1982	····NDOMapping mapping;
1983	····Class ownClass;
1984	····Class otherClass;
1985	····Class otherDerivedClass;
1986	····[SetUp]
1987	····public void Setup()
1988	····{
1989	········this.pm = PmFactory.NewPersistenceManager();
1990	········this.mapping = pm.NDOMapping;
1991	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpconTblAutoLeft" );
1992	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpconTblAutoRightBase" );
1993	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpconTblAutoRightDerived" );
1994	····}
1995	····[Test]
1996	····public void HasMappingTable()
1997	····{
1998	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
1999	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
2000	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
2001	····}
2002	····[Test]
2003	····public void HasTypeColumn()
2004	····{
2005	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2006	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
2007	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
2008	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
2009	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
2010	····}
2011	····[Test]
2012	····public void HasTypeCode()
2013	····{
2014	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2015	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2016	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2017	····}
2018	}
2019
2020
2021	[TestFixture]
2022	public class MappingTestCmpDir1OthpconTblAuto : NDOTest
2023	{
2024	····PersistenceManager pm;
2025	····NDOMapping mapping;
2026	····Class ownClass;
2027	····Class otherClass;
2028	····Class otherDerivedClass;
2029	····[SetUp]
2030	····public void Setup()
2031	····{
2032	········this.pm = PmFactory.NewPersistenceManager();
2033	········this.mapping = pm.NDOMapping;
2034	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconTblAutoLeft" );
2035	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconTblAutoRightBase" );
2036	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconTblAutoRightDerived" );
2037	····}
2038	····[Test]
2039	····public void HasMappingTable()
2040	····{
2041	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2042	····}
2043	····[Test]
2044	····public void HasTypeColumn()
2045	····{
2046	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2047	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
2048	····}
2049	····[Test]
2050	····public void HasTypeCode()
2051	····{
2052	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2053	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2054	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2055	····}
2056	}
2057
2058
2059	[TestFixture]
2060	public class MappingTestCmpBi11OthpconTblAuto : NDOTest
2061	{
2062	····PersistenceManager pm;
2063	····NDOMapping mapping;
2064	····Class ownClass;
2065	····Class otherClass;
2066	····Class otherDerivedClass;
2067	····[SetUp]
2068	····public void Setup()
2069	····{
2070	········this.pm = PmFactory.NewPersistenceManager();
2071	········this.mapping = pm.NDOMapping;
2072	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconTblAutoLeft" );
2073	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconTblAutoRightBase" );
2074	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconTblAutoRightDerived" );
2075	····}
2076	····[Test]
2077	····public void HasMappingTable()
2078	····{
2079	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2080	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
2081	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
2082	····}
2083	····[Test]
2084	····public void HasTypeColumn()
2085	····{
2086	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2087	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
2088	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
2089	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
2090	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
2091	····}
2092	····[Test]
2093	····public void HasTypeCode()
2094	····{
2095	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2096	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2097	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2098	····}
2099	}
2100
2101
2102	[TestFixture]
2103	public class MappingTestCmpDirnOthpconTblAuto : NDOTest
2104	{
2105	····PersistenceManager pm;
2106	····NDOMapping mapping;
2107	····Class ownClass;
2108	····Class otherClass;
2109	····Class otherDerivedClass;
2110	····[SetUp]
2111	····public void Setup()
2112	····{
2113	········this.pm = PmFactory.NewPersistenceManager();
2114	········this.mapping = pm.NDOMapping;
2115	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpconTblAutoLeft" );
2116	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpconTblAutoRightBase" );
2117	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpconTblAutoRightDerived" );
2118	····}
2119	····[Test]
2120	····public void HasMappingTable()
2121	····{
2122	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2123	····}
2124	····[Test]
2125	····public void HasTypeColumn()
2126	····{
2127	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2128	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
2129	····}
2130	····[Test]
2131	····public void HasTypeCode()
2132	····{
2133	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2134	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2135	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2136	····}
2137	}
2138
2139
2140	[TestFixture]
2141	public class MappingTestCmpBin1OthpconTblAuto : NDOTest
2142	{
2143	····PersistenceManager pm;
2144	····NDOMapping mapping;
2145	····Class ownClass;
2146	····Class otherClass;
2147	····Class otherDerivedClass;
2148	····[SetUp]
2149	····public void Setup()
2150	····{
2151	········this.pm = PmFactory.NewPersistenceManager();
2152	········this.mapping = pm.NDOMapping;
2153	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpconTblAutoLeft" );
2154	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpconTblAutoRightBase" );
2155	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpconTblAutoRightDerived" );
2156	····}
2157	····[Test]
2158	····public void HasMappingTable()
2159	····{
2160	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2161	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
2162	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
2163	····}
2164	····[Test]
2165	····public void HasTypeColumn()
2166	····{
2167	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2168	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
2169	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
2170	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
2171	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
2172	····}
2173	····[Test]
2174	····public void HasTypeCode()
2175	····{
2176	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2177	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2178	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2179	····}
2180	}
2181
2182
2183	[TestFixture]
2184	public class MappingTestCmpBi1nOthpconTblAuto : NDOTest
2185	{
2186	····PersistenceManager pm;
2187	····NDOMapping mapping;
2188	····Class ownClass;
2189	····Class otherClass;
2190	····Class otherDerivedClass;
2191	····[SetUp]
2192	····public void Setup()
2193	····{
2194	········this.pm = PmFactory.NewPersistenceManager();
2195	········this.mapping = pm.NDOMapping;
2196	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconTblAutoLeft" );
2197	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconTblAutoRightBase" );
2198	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconTblAutoRightDerived" );
2199	····}
2200	····[Test]
2201	····public void HasMappingTable()
2202	····{
2203	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2204	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
2205	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
2206	····}
2207	····[Test]
2208	····public void HasTypeColumn()
2209	····{
2210	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2211	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
2212	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
2213	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
2214	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
2215	····}
2216	····[Test]
2217	····public void HasTypeCode()
2218	····{
2219	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2220	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2221	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2222	····}
2223	}
2224
2225
2226	[TestFixture]
2227	public class MappingTestCmpBinnOthpconTblAuto : NDOTest
2228	{
2229	····PersistenceManager pm;
2230	····NDOMapping mapping;
2231	····Class ownClass;
2232	····Class otherClass;
2233	····Class otherDerivedClass;
2234	····[SetUp]
2235	····public void Setup()
2236	····{
2237	········this.pm = PmFactory.NewPersistenceManager();
2238	········this.mapping = pm.NDOMapping;
2239	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpconTblAutoLeft" );
2240	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpconTblAutoRightBase" );
2241	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpconTblAutoRightDerived" );
2242	····}
2243	····[Test]
2244	····public void HasMappingTable()
2245	····{
2246	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2247	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
2248	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
2249	····}
2250	····[Test]
2251	····public void HasTypeColumn()
2252	····{
2253	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2254	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
2255	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
2256	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
2257	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
2258	····}
2259	····[Test]
2260	····public void HasTypeCode()
2261	····{
2262	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2263	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2264	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2265	····}
2266	}
2267
2268
2269	[TestFixture]
2270	public class MappingTestAgrDir1OwnpconOthpconNoTblAuto : NDOTest
2271	{
2272	····PersistenceManager pm;
2273	····NDOMapping mapping;
2274	····Class ownClass;
2275	····Class otherClass;
2276	····Class ownDerivedClass;
2277	····Class otherDerivedClass;
2278	····[SetUp]
2279	····public void Setup()
2280	····{
2281	········this.pm = PmFactory.NewPersistenceManager();
2282	········this.mapping = pm.NDOMapping;
2283	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconNoTblAutoLeftBase" );
2284	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconNoTblAutoRightBase" );
2285	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconNoTblAutoLeftDerived" );
2286	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconNoTblAutoRightDerived" );
2287	····}
2288	····[Test]
2289	····public void HasMappingTable()
2290	····{
2291	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
2292	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
2293	····}
2294	····[Test]
2295	····public void HasTypeColumn()
2296	····{
2297	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
2298	····}
2299	····[Test]
2300	····public void HasTypeCode()
2301	····{
2302	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2303	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2304	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2305	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2306	····}
2307	}
2308
2309
2310	[TestFixture]
2311	public class MappingTestAgrDir1OwnpconOthpconTblAuto : NDOTest
2312	{
2313	····PersistenceManager pm;
2314	····NDOMapping mapping;
2315	····Class ownClass;
2316	····Class otherClass;
2317	····Class ownDerivedClass;
2318	····Class otherDerivedClass;
2319	····[SetUp]
2320	····public void Setup()
2321	····{
2322	········this.pm = PmFactory.NewPersistenceManager();
2323	········this.mapping = pm.NDOMapping;
2324	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconTblAutoLeftBase" );
2325	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconTblAutoRightBase" );
2326	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconTblAutoLeftDerived" );
2327	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconTblAutoRightDerived" );
2328	····}
2329	····[Test]
2330	····public void HasMappingTable()
2331	····{
2332	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2333	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
2334	····}
2335	····[Test]
2336	····public void HasTypeColumn()
2337	····{
2338	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
2339	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
2340	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2341	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
2342	····}
2343	····[Test]
2344	····public void HasTypeCode()
2345	····{
2346	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2347	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2348	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2349	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2350	····}
2351	}
2352
2353
2354	[TestFixture]
2355	public class MappingTestAgrBi11OwnpconOthpconNoTblAuto : NDOTest
2356	{
2357	····PersistenceManager pm;
2358	····NDOMapping mapping;
2359	····Class ownClass;
2360	····Class otherClass;
2361	····Class ownDerivedClass;
2362	····Class otherDerivedClass;
2363	····[SetUp]
2364	····public void Setup()
2365	····{
2366	········this.pm = PmFactory.NewPersistenceManager();
2367	········this.mapping = pm.NDOMapping;
2368	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconNoTblAutoLeftBase" );
2369	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconNoTblAutoRightBase" );
2370	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconNoTblAutoLeftDerived" );
2371	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconNoTblAutoRightDerived" );
2372	····}
2373	····[Test]
2374	····public void HasMappingTable()
2375	····{
2376	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
2377	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
2378	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
2379	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
2380	····}
2381	····[Test]
2382	····public void HasTypeColumn()
2383	····{
2384	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
2385	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #10");
2386	····}
2387	····[Test]
2388	····public void HasTypeCode()
2389	····{
2390	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2391	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2392	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2393	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2394	····}
2395	}
2396
2397
2398	[TestFixture]
2399	public class MappingTestAgrBi11OwnpconOthpconTblAuto : NDOTest
2400	{
2401	····PersistenceManager pm;
2402	····NDOMapping mapping;
2403	····Class ownClass;
2404	····Class otherClass;
2405	····Class ownDerivedClass;
2406	····Class otherDerivedClass;
2407	····[SetUp]
2408	····public void Setup()
2409	····{
2410	········this.pm = PmFactory.NewPersistenceManager();
2411	········this.mapping = pm.NDOMapping;
2412	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconTblAutoLeftBase" );
2413	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconTblAutoRightBase" );
2414	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconTblAutoLeftDerived" );
2415	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconTblAutoRightDerived" );
2416	····}
2417	····[Test]
2418	····public void HasMappingTable()
2419	····{
2420	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2421	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
2422	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
2423	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
2424	····}
2425	····[Test]
2426	····public void HasTypeColumn()
2427	····{
2428	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
2429	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
2430	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2431	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
2432	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
2433	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
2434	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
2435	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
2436	····}
2437	····[Test]
2438	····public void HasTypeCode()
2439	····{
2440	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2441	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2442	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2443	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2444	····}
2445	}
2446
2447
2448	[TestFixture]
2449	public class MappingTestAgrDirnOwnpconOthpconTblAuto : NDOTest
2450	{
2451	····PersistenceManager pm;
2452	····NDOMapping mapping;
2453	····Class ownClass;
2454	····Class otherClass;
2455	····Class ownDerivedClass;
2456	····Class otherDerivedClass;
2457	····[SetUp]
2458	····public void Setup()
2459	····{
2460	········this.pm = PmFactory.NewPersistenceManager();
2461	········this.mapping = pm.NDOMapping;
2462	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconOthpconTblAutoLeftBase" );
2463	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconOthpconTblAutoRightBase" );
2464	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconOthpconTblAutoLeftDerived" );
2465	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconOthpconTblAutoRightDerived" );
2466	····}
2467	····[Test]
2468	····public void HasMappingTable()
2469	····{
2470	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2471	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
2472	····}
2473	····[Test]
2474	····public void HasTypeColumn()
2475	····{
2476	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
2477	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
2478	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2479	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
2480	····}
2481	····[Test]
2482	····public void HasTypeCode()
2483	····{
2484	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2485	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2486	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2487	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2488	····}
2489	}
2490
2491
2492	[TestFixture]
2493	public class MappingTestAgrBin1OwnpconOthpconTblAuto : NDOTest
2494	{
2495	····PersistenceManager pm;
2496	····NDOMapping mapping;
2497	····Class ownClass;
2498	····Class otherClass;
2499	····Class ownDerivedClass;
2500	····Class otherDerivedClass;
2501	····[SetUp]
2502	····public void Setup()
2503	····{
2504	········this.pm = PmFactory.NewPersistenceManager();
2505	········this.mapping = pm.NDOMapping;
2506	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconOthpconTblAutoLeftBase" );
2507	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconOthpconTblAutoRightBase" );
2508	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconOthpconTblAutoLeftDerived" );
2509	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconOthpconTblAutoRightDerived" );
2510	····}
2511	····[Test]
2512	····public void HasMappingTable()
2513	····{
2514	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2515	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
2516	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
2517	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
2518	····}
2519	····[Test]
2520	····public void HasTypeColumn()
2521	····{
2522	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
2523	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
2524	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2525	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
2526	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
2527	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
2528	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
2529	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
2530	····}
2531	····[Test]
2532	····public void HasTypeCode()
2533	····{
2534	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2535	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2536	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2537	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2538	····}
2539	}
2540
2541
2542	[TestFixture]
2543	public class MappingTestAgrBi1nOwnpconOthpconTblAuto : NDOTest
2544	{
2545	····PersistenceManager pm;
2546	····NDOMapping mapping;
2547	····Class ownClass;
2548	····Class otherClass;
2549	····Class ownDerivedClass;
2550	····Class otherDerivedClass;
2551	····[SetUp]
2552	····public void Setup()
2553	····{
2554	········this.pm = PmFactory.NewPersistenceManager();
2555	········this.mapping = pm.NDOMapping;
2556	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconOthpconTblAutoLeftBase" );
2557	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconOthpconTblAutoRightBase" );
2558	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconOthpconTblAutoLeftDerived" );
2559	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconOthpconTblAutoRightDerived" );
2560	····}
2561	····[Test]
2562	····public void HasMappingTable()
2563	····{
2564	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2565	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
2566	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
2567	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
2568	····}
2569	····[Test]
2570	····public void HasTypeColumn()
2571	····{
2572	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
2573	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
2574	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2575	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
2576	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
2577	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
2578	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
2579	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
2580	····}
2581	····[Test]
2582	····public void HasTypeCode()
2583	····{
2584	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2585	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2586	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2587	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2588	····}
2589	}
2590
2591
2592	[TestFixture]
2593	public class MappingTestAgrBinnOwnpconOthpconTblAuto : NDOTest
2594	{
2595	····PersistenceManager pm;
2596	····NDOMapping mapping;
2597	····Class ownClass;
2598	····Class otherClass;
2599	····Class ownDerivedClass;
2600	····Class otherDerivedClass;
2601	····[SetUp]
2602	····public void Setup()
2603	····{
2604	········this.pm = PmFactory.NewPersistenceManager();
2605	········this.mapping = pm.NDOMapping;
2606	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconOthpconTblAutoLeftBase" );
2607	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconOthpconTblAutoRightBase" );
2608	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconOthpconTblAutoLeftDerived" );
2609	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconOthpconTblAutoRightDerived" );
2610	····}
2611	····[Test]
2612	····public void HasMappingTable()
2613	····{
2614	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2615	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
2616	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
2617	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
2618	····}
2619	····[Test]
2620	····public void HasTypeColumn()
2621	····{
2622	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
2623	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
2624	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2625	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
2626	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
2627	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
2628	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
2629	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
2630	····}
2631	····[Test]
2632	····public void HasTypeCode()
2633	····{
2634	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2635	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2636	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2637	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2638	····}
2639	}
2640
2641
2642	[TestFixture]
2643	public class MappingTestCmpDir1OwnpconOthpconTblAuto : NDOTest
2644	{
2645	····PersistenceManager pm;
2646	····NDOMapping mapping;
2647	····Class ownClass;
2648	····Class otherClass;
2649	····Class ownDerivedClass;
2650	····Class otherDerivedClass;
2651	····[SetUp]
2652	····public void Setup()
2653	····{
2654	········this.pm = PmFactory.NewPersistenceManager();
2655	········this.mapping = pm.NDOMapping;
2656	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconTblAutoLeftBase" );
2657	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconTblAutoRightBase" );
2658	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconTblAutoLeftDerived" );
2659	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconTblAutoRightDerived" );
2660	····}
2661	····[Test]
2662	····public void HasMappingTable()
2663	····{
2664	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2665	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
2666	····}
2667	····[Test]
2668	····public void HasTypeColumn()
2669	····{
2670	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
2671	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
2672	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2673	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
2674	····}
2675	····[Test]
2676	····public void HasTypeCode()
2677	····{
2678	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2679	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2680	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2681	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2682	····}
2683	}
2684
2685
2686	[TestFixture]
2687	public class MappingTestCmpBi11OwnpconOthpconTblAuto : NDOTest
2688	{
2689	····PersistenceManager pm;
2690	····NDOMapping mapping;
2691	····Class ownClass;
2692	····Class otherClass;
2693	····Class ownDerivedClass;
2694	····Class otherDerivedClass;
2695	····[SetUp]
2696	····public void Setup()
2697	····{
2698	········this.pm = PmFactory.NewPersistenceManager();
2699	········this.mapping = pm.NDOMapping;
2700	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconTblAutoLeftBase" );
2701	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconTblAutoRightBase" );
2702	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconTblAutoLeftDerived" );
2703	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconTblAutoRightDerived" );
2704	····}
2705	····[Test]
2706	····public void HasMappingTable()
2707	····{
2708	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2709	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
2710	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
2711	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
2712	····}
2713	····[Test]
2714	····public void HasTypeColumn()
2715	····{
2716	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
2717	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
2718	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2719	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
2720	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
2721	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
2722	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
2723	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
2724	····}
2725	····[Test]
2726	····public void HasTypeCode()
2727	····{
2728	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2729	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2730	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2731	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2732	····}
2733	}
2734
2735
2736	[TestFixture]
2737	public class MappingTestCmpDirnOwnpconOthpconTblAuto : NDOTest
2738	{
2739	····PersistenceManager pm;
2740	····NDOMapping mapping;
2741	····Class ownClass;
2742	····Class otherClass;
2743	····Class ownDerivedClass;
2744	····Class otherDerivedClass;
2745	····[SetUp]
2746	····public void Setup()
2747	····{
2748	········this.pm = PmFactory.NewPersistenceManager();
2749	········this.mapping = pm.NDOMapping;
2750	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconOthpconTblAutoLeftBase" );
2751	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconOthpconTblAutoRightBase" );
2752	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconOthpconTblAutoLeftDerived" );
2753	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconOthpconTblAutoRightDerived" );
2754	····}
2755	····[Test]
2756	····public void HasMappingTable()
2757	····{
2758	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2759	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
2760	····}
2761	····[Test]
2762	····public void HasTypeColumn()
2763	····{
2764	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
2765	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
2766	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2767	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
2768	····}
2769	····[Test]
2770	····public void HasTypeCode()
2771	····{
2772	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2773	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2774	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2775	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2776	····}
2777	}
2778
2779
2780	[TestFixture]
2781	public class MappingTestCmpBin1OwnpconOthpconTblAuto : NDOTest
2782	{
2783	····PersistenceManager pm;
2784	····NDOMapping mapping;
2785	····Class ownClass;
2786	····Class otherClass;
2787	····Class ownDerivedClass;
2788	····Class otherDerivedClass;
2789	····[SetUp]
2790	····public void Setup()
2791	····{
2792	········this.pm = PmFactory.NewPersistenceManager();
2793	········this.mapping = pm.NDOMapping;
2794	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconOthpconTblAutoLeftBase" );
2795	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconOthpconTblAutoRightBase" );
2796	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconOthpconTblAutoLeftDerived" );
2797	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconOthpconTblAutoRightDerived" );
2798	····}
2799	····[Test]
2800	····public void HasMappingTable()
2801	····{
2802	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2803	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
2804	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
2805	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
2806	····}
2807	····[Test]
2808	····public void HasTypeColumn()
2809	····{
2810	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
2811	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
2812	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2813	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
2814	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
2815	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
2816	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
2817	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
2818	····}
2819	····[Test]
2820	····public void HasTypeCode()
2821	····{
2822	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2823	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2824	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2825	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2826	····}
2827	}
2828
2829
2830	[TestFixture]
2831	public class MappingTestCmpBi1nOwnpconOthpconTblAuto : NDOTest
2832	{
2833	····PersistenceManager pm;
2834	····NDOMapping mapping;
2835	····Class ownClass;
2836	····Class otherClass;
2837	····Class ownDerivedClass;
2838	····Class otherDerivedClass;
2839	····[SetUp]
2840	····public void Setup()
2841	····{
2842	········this.pm = PmFactory.NewPersistenceManager();
2843	········this.mapping = pm.NDOMapping;
2844	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconOthpconTblAutoLeftBase" );
2845	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconOthpconTblAutoRightBase" );
2846	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconOthpconTblAutoLeftDerived" );
2847	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconOthpconTblAutoRightDerived" );
2848	····}
2849	····[Test]
2850	····public void HasMappingTable()
2851	····{
2852	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2853	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
2854	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
2855	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
2856	····}
2857	····[Test]
2858	····public void HasTypeColumn()
2859	····{
2860	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
2861	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
2862	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2863	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
2864	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
2865	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
2866	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
2867	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
2868	····}
2869	····[Test]
2870	····public void HasTypeCode()
2871	····{
2872	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2873	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2874	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2875	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2876	····}
2877	}
2878
2879
2880	[TestFixture]
2881	public class MappingTestCmpBinnOwnpconOthpconTblAuto : NDOTest
2882	{
2883	····PersistenceManager pm;
2884	····NDOMapping mapping;
2885	····Class ownClass;
2886	····Class otherClass;
2887	····Class ownDerivedClass;
2888	····Class otherDerivedClass;
2889	····[SetUp]
2890	····public void Setup()
2891	····{
2892	········this.pm = PmFactory.NewPersistenceManager();
2893	········this.mapping = pm.NDOMapping;
2894	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconOthpconTblAutoLeftBase" );
2895	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconOthpconTblAutoRightBase" );
2896	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconOthpconTblAutoLeftDerived" );
2897	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconOthpconTblAutoRightDerived" );
2898	····}
2899	····[Test]
2900	····public void HasMappingTable()
2901	····{
2902	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2903	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
2904	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
2905	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
2906	····}
2907	····[Test]
2908	····public void HasTypeColumn()
2909	····{
2910	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
2911	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
2912	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2913	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
2914	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
2915	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
2916	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
2917	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
2918	····}
2919	····[Test]
2920	····public void HasTypeCode()
2921	····{
2922	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2923	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2924	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2925	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2926	····}
2927	}
2928
2929
2930	[TestFixture]
2931	public class MappingTestAgrDir1NoTblGuid : NDOTest
2932	{
2933	····PersistenceManager pm;
2934	····NDOMapping mapping;
2935	····Class ownClass;
2936	····Class otherClass;
2937	····[SetUp]
2938	····public void Setup()
2939	····{
2940	········this.pm = PmFactory.NewPersistenceManager();
2941	········this.mapping = pm.NDOMapping;
2942	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1NoTblGuidLeft" );
2943	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1NoTblGuidRight" );
2944	····}
2945	····[Test]
2946	····public void HasMappingTable()
2947	····{
2948	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
2949	····}
2950	····[Test]
2951	····public void HasTypeColumn()
2952	····{
2953	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
2954	····}
2955	····[Test]
2956	····public void HasTypeCode()
2957	····{
2958	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2959	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2960	····}
2961	}
2962
2963
2964	[TestFixture]
2965	public class MappingTestAgrDir1TblGuid : NDOTest
2966	{
2967	····PersistenceManager pm;
2968	····NDOMapping mapping;
2969	····Class ownClass;
2970	····Class otherClass;
2971	····[SetUp]
2972	····public void Setup()
2973	····{
2974	········this.pm = PmFactory.NewPersistenceManager();
2975	········this.mapping = pm.NDOMapping;
2976	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1TblGuidLeft" );
2977	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1TblGuidRight" );
2978	····}
2979	····[Test]
2980	····public void HasMappingTable()
2981	····{
2982	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2983	····}
2984	····[Test]
2985	····public void HasTypeColumn()
2986	····{
2987	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
2988	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
2989	····}
2990	····[Test]
2991	····public void HasTypeCode()
2992	····{
2993	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2994	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2995	····}
2996	}
2997
2998
2999	[TestFixture]
3000	public class MappingTestAgrBi11NoTblGuid : NDOTest
3001	{
3002	····PersistenceManager pm;
3003	····NDOMapping mapping;
3004	····Class ownClass;
3005	····Class otherClass;
3006	····[SetUp]
3007	····public void Setup()
3008	····{
3009	········this.pm = PmFactory.NewPersistenceManager();
3010	········this.mapping = pm.NDOMapping;
3011	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11NoTblGuidLeft" );
3012	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11NoTblGuidRight" );
3013	····}
3014	····[Test]
3015	····public void HasMappingTable()
3016	····{
3017	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
3018	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
3019	····}
3020	····[Test]
3021	····public void HasTypeColumn()
3022	····{
3023	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3024	····}
3025	····[Test]
3026	····public void HasTypeCode()
3027	····{
3028	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3029	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3030	····}
3031	}
3032
3033
3034	[TestFixture]
3035	public class MappingTestAgrBi11TblGuid : NDOTest
3036	{
3037	····PersistenceManager pm;
3038	····NDOMapping mapping;
3039	····Class ownClass;
3040	····Class otherClass;
3041	····[SetUp]
3042	····public void Setup()
3043	····{
3044	········this.pm = PmFactory.NewPersistenceManager();
3045	········this.mapping = pm.NDOMapping;
3046	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11TblGuidLeft" );
3047	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11TblGuidRight" );
3048	····}
3049	····[Test]
3050	····public void HasMappingTable()
3051	····{
3052	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
3053	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
3054	····}
3055	····[Test]
3056	····public void HasTypeColumn()
3057	····{
3058	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3059	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
3060	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
3061	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
3062	····}
3063	····[Test]
3064	····public void HasTypeCode()
3065	····{
3066	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3067	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3068	····}
3069	}
3070
3071
3072	[TestFixture]
3073	public class MappingTestAgrDirnNoTblGuid : NDOTest
3074	{
3075	····PersistenceManager pm;
3076	····NDOMapping mapping;
3077	····Class ownClass;
3078	····Class otherClass;
3079	····[SetUp]
3080	····public void Setup()
3081	····{
3082	········this.pm = PmFactory.NewPersistenceManager();
3083	········this.mapping = pm.NDOMapping;
3084	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnNoTblGuidLeft" );
3085	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnNoTblGuidRight" );
3086	····}
3087	····[Test]
3088	····public void HasMappingTable()
3089	····{
3090	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
3091	····}
3092	····[Test]
3093	····public void HasTypeColumn()
3094	····{
3095	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3096	····}
3097	····[Test]
3098	····public void HasTypeCode()
3099	····{
3100	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3101	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3102	····}
3103	}
3104
3105
3106	[TestFixture]
3107	public class MappingTestAgrDirnTblGuid : NDOTest
3108	{
3109	····PersistenceManager pm;
3110	····NDOMapping mapping;
3111	····Class ownClass;
3112	····Class otherClass;
3113	····[SetUp]
3114	····public void Setup()
3115	····{
3116	········this.pm = PmFactory.NewPersistenceManager();
3117	········this.mapping = pm.NDOMapping;
3118	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnTblGuidLeft" );
3119	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnTblGuidRight" );
3120	····}
3121	····[Test]
3122	····public void HasMappingTable()
3123	····{
3124	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
3125	····}
3126	····[Test]
3127	····public void HasTypeColumn()
3128	····{
3129	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3130	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
3131	····}
3132	····[Test]
3133	····public void HasTypeCode()
3134	····{
3135	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3136	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3137	····}
3138	}
3139
3140
3141	[TestFixture]
3142	public class MappingTestAgrBin1NoTblGuid : NDOTest
3143	{
3144	····PersistenceManager pm;
3145	····NDOMapping mapping;
3146	····Class ownClass;
3147	····Class otherClass;
3148	····[SetUp]
3149	····public void Setup()
3150	····{
3151	········this.pm = PmFactory.NewPersistenceManager();
3152	········this.mapping = pm.NDOMapping;
3153	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1NoTblGuidLeft" );
3154	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1NoTblGuidRight" );
3155	····}
3156	····[Test]
3157	····public void HasMappingTable()
3158	····{
3159	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
3160	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
3161	····}
3162	····[Test]
3163	····public void HasTypeColumn()
3164	····{
3165	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3166	····}
3167	····[Test]
3168	····public void HasTypeCode()
3169	····{
3170	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3171	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3172	····}
3173	}
3174
3175
3176	[TestFixture]
3177	public class MappingTestAgrBin1TblGuid : NDOTest
3178	{
3179	····PersistenceManager pm;
3180	····NDOMapping mapping;
3181	····Class ownClass;
3182	····Class otherClass;
3183	····[SetUp]
3184	····public void Setup()
3185	····{
3186	········this.pm = PmFactory.NewPersistenceManager();
3187	········this.mapping = pm.NDOMapping;
3188	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1TblGuidLeft" );
3189	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1TblGuidRight" );
3190	····}
3191	····[Test]
3192	····public void HasMappingTable()
3193	····{
3194	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
3195	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
3196	····}
3197	····[Test]
3198	····public void HasTypeColumn()
3199	····{
3200	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3201	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
3202	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
3203	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
3204	····}
3205	····[Test]
3206	····public void HasTypeCode()
3207	····{
3208	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3209	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3210	····}
3211	}
3212
3213
3214	[TestFixture]
3215	public class MappingTestAgrBi1nNoTblGuid : NDOTest
3216	{
3217	····PersistenceManager pm;
3218	····NDOMapping mapping;
3219	····Class ownClass;
3220	····Class otherClass;
3221	····[SetUp]
3222	····public void Setup()
3223	····{
3224	········this.pm = PmFactory.NewPersistenceManager();
3225	········this.mapping = pm.NDOMapping;
3226	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nNoTblGuidLeft" );
3227	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nNoTblGuidRight" );
3228	····}
3229	····[Test]
3230	····public void HasMappingTable()
3231	····{
3232	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
3233	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
3234	····}
3235	····[Test]
3236	····public void HasTypeColumn()
3237	····{
3238	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3239	····}
3240	····[Test]
3241	····public void HasTypeCode()
3242	····{
3243	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3244	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3245	····}
3246	}
3247
3248
3249	[TestFixture]
3250	public class MappingTestAgrBi1nTblGuid : NDOTest
3251	{
3252	····PersistenceManager pm;
3253	····NDOMapping mapping;
3254	····Class ownClass;
3255	····Class otherClass;
3256	····[SetUp]
3257	····public void Setup()
3258	····{
3259	········this.pm = PmFactory.NewPersistenceManager();
3260	········this.mapping = pm.NDOMapping;
3261	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nTblGuidLeft" );
3262	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nTblGuidRight" );
3263	····}
3264	····[Test]
3265	····public void HasMappingTable()
3266	····{
3267	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
3268	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
3269	····}
3270	····[Test]
3271	····public void HasTypeColumn()
3272	····{
3273	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3274	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
3275	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
3276	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
3277	····}
3278	····[Test]
3279	····public void HasTypeCode()
3280	····{
3281	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3282	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3283	····}
3284	}
3285
3286
3287	[TestFixture]
3288	public class MappingTestAgrBinnTblGuid : NDOTest
3289	{
3290	····PersistenceManager pm;
3291	····NDOMapping mapping;
3292	····Class ownClass;
3293	····Class otherClass;
3294	····[SetUp]
3295	····public void Setup()
3296	····{
3297	········this.pm = PmFactory.NewPersistenceManager();
3298	········this.mapping = pm.NDOMapping;
3299	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnTblGuidLeft" );
3300	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnTblGuidRight" );
3301	····}
3302	····[Test]
3303	····public void HasMappingTable()
3304	····{
3305	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
3306	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
3307	····}
3308	····[Test]
3309	····public void HasTypeColumn()
3310	····{
3311	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3312	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
3313	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
3314	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
3315	····}
3316	····[Test]
3317	····public void HasTypeCode()
3318	····{
3319	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3320	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3321	····}
3322	}
3323
3324
3325	[TestFixture]
3326	public class MappingTestCmpDir1NoTblGuid : NDOTest
3327	{
3328	····PersistenceManager pm;
3329	····NDOMapping mapping;
3330	····Class ownClass;
3331	····Class otherClass;
3332	····[SetUp]
3333	····public void Setup()
3334	····{
3335	········this.pm = PmFactory.NewPersistenceManager();
3336	········this.mapping = pm.NDOMapping;
3337	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1NoTblGuidLeft" );
3338	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1NoTblGuidRight" );
3339	····}
3340	····[Test]
3341	····public void HasMappingTable()
3342	····{
3343	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
3344	····}
3345	····[Test]
3346	····public void HasTypeColumn()
3347	····{
3348	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3349	····}
3350	····[Test]
3351	····public void HasTypeCode()
3352	····{
3353	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3354	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3355	····}
3356	}
3357
3358
3359	[TestFixture]
3360	public class MappingTestCmpDir1TblGuid : NDOTest
3361	{
3362	····PersistenceManager pm;
3363	····NDOMapping mapping;
3364	····Class ownClass;
3365	····Class otherClass;
3366	····[SetUp]
3367	····public void Setup()
3368	····{
3369	········this.pm = PmFactory.NewPersistenceManager();
3370	········this.mapping = pm.NDOMapping;
3371	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1TblGuidLeft" );
3372	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1TblGuidRight" );
3373	····}
3374	····[Test]
3375	····public void HasMappingTable()
3376	····{
3377	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
3378	····}
3379	····[Test]
3380	····public void HasTypeColumn()
3381	····{
3382	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3383	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
3384	····}
3385	····[Test]
3386	····public void HasTypeCode()
3387	····{
3388	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3389	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3390	····}
3391	}
3392
3393
3394	[TestFixture]
3395	public class MappingTestCmpBi11NoTblGuid : NDOTest
3396	{
3397	····PersistenceManager pm;
3398	····NDOMapping mapping;
3399	····Class ownClass;
3400	····Class otherClass;
3401	····[SetUp]
3402	····public void Setup()
3403	····{
3404	········this.pm = PmFactory.NewPersistenceManager();
3405	········this.mapping = pm.NDOMapping;
3406	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11NoTblGuidLeft" );
3407	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11NoTblGuidRight" );
3408	····}
3409	····[Test]
3410	····public void HasMappingTable()
3411	····{
3412	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
3413	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
3414	····}
3415	····[Test]
3416	····public void HasTypeColumn()
3417	····{
3418	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3419	····}
3420	····[Test]
3421	····public void HasTypeCode()
3422	····{
3423	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3424	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3425	····}
3426	}
3427
3428
3429	[TestFixture]
3430	public class MappingTestCmpBi11TblGuid : NDOTest
3431	{
3432	····PersistenceManager pm;
3433	····NDOMapping mapping;
3434	····Class ownClass;
3435	····Class otherClass;
3436	····[SetUp]
3437	····public void Setup()
3438	····{
3439	········this.pm = PmFactory.NewPersistenceManager();
3440	········this.mapping = pm.NDOMapping;
3441	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11TblGuidLeft" );
3442	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11TblGuidRight" );
3443	····}
3444	····[Test]
3445	····public void HasMappingTable()
3446	····{
3447	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
3448	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
3449	····}
3450	····[Test]
3451	····public void HasTypeColumn()
3452	····{
3453	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3454	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
3455	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
3456	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
3457	····}
3458	····[Test]
3459	····public void HasTypeCode()
3460	····{
3461	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3462	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3463	····}
3464	}
3465
3466
3467	[TestFixture]
3468	public class MappingTestCmpDirnNoTblGuid : NDOTest
3469	{
3470	····PersistenceManager pm;
3471	····NDOMapping mapping;
3472	····Class ownClass;
3473	····Class otherClass;
3474	····[SetUp]
3475	····public void Setup()
3476	····{
3477	········this.pm = PmFactory.NewPersistenceManager();
3478	········this.mapping = pm.NDOMapping;
3479	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnNoTblGuidLeft" );
3480	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnNoTblGuidRight" );
3481	····}
3482	····[Test]
3483	····public void HasMappingTable()
3484	····{
3485	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
3486	····}
3487	····[Test]
3488	····public void HasTypeColumn()
3489	····{
3490	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3491	····}
3492	····[Test]
3493	····public void HasTypeCode()
3494	····{
3495	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3496	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3497	····}
3498	}
3499
3500
3501	[TestFixture]
3502	public class MappingTestCmpDirnTblGuid : NDOTest
3503	{
3504	····PersistenceManager pm;
3505	····NDOMapping mapping;
3506	····Class ownClass;
3507	····Class otherClass;
3508	····[SetUp]
3509	····public void Setup()
3510	····{
3511	········this.pm = PmFactory.NewPersistenceManager();
3512	········this.mapping = pm.NDOMapping;
3513	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnTblGuidLeft" );
3514	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnTblGuidRight" );
3515	····}
3516	····[Test]
3517	····public void HasMappingTable()
3518	····{
3519	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
3520	····}
3521	····[Test]
3522	····public void HasTypeColumn()
3523	····{
3524	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3525	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
3526	····}
3527	····[Test]
3528	····public void HasTypeCode()
3529	····{
3530	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3531	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3532	····}
3533	}
3534
3535
3536	[TestFixture]
3537	public class MappingTestCmpBin1NoTblGuid : NDOTest
3538	{
3539	····PersistenceManager pm;
3540	····NDOMapping mapping;
3541	····Class ownClass;
3542	····Class otherClass;
3543	····[SetUp]
3544	····public void Setup()
3545	····{
3546	········this.pm = PmFactory.NewPersistenceManager();
3547	········this.mapping = pm.NDOMapping;
3548	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1NoTblGuidLeft" );
3549	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1NoTblGuidRight" );
3550	····}
3551	····[Test]
3552	····public void HasMappingTable()
3553	····{
3554	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
3555	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
3556	····}
3557	····[Test]
3558	····public void HasTypeColumn()
3559	····{
3560	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3561	····}
3562	····[Test]
3563	····public void HasTypeCode()
3564	····{
3565	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3566	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3567	····}
3568	}
3569
3570
3571	[TestFixture]
3572	public class MappingTestCmpBin1TblGuid : NDOTest
3573	{
3574	····PersistenceManager pm;
3575	····NDOMapping mapping;
3576	····Class ownClass;
3577	····Class otherClass;
3578	····[SetUp]
3579	····public void Setup()
3580	····{
3581	········this.pm = PmFactory.NewPersistenceManager();
3582	········this.mapping = pm.NDOMapping;
3583	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1TblGuidLeft" );
3584	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1TblGuidRight" );
3585	····}
3586	····[Test]
3587	····public void HasMappingTable()
3588	····{
3589	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
3590	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
3591	····}
3592	····[Test]
3593	····public void HasTypeColumn()
3594	····{
3595	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3596	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
3597	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
3598	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
3599	····}
3600	····[Test]
3601	····public void HasTypeCode()
3602	····{
3603	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3604	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3605	····}
3606	}
3607
3608
3609	[TestFixture]
3610	public class MappingTestCmpBi1nNoTblGuid : NDOTest
3611	{
3612	····PersistenceManager pm;
3613	····NDOMapping mapping;
3614	····Class ownClass;
3615	····Class otherClass;
3616	····[SetUp]
3617	····public void Setup()
3618	····{
3619	········this.pm = PmFactory.NewPersistenceManager();
3620	········this.mapping = pm.NDOMapping;
3621	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nNoTblGuidLeft" );
3622	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nNoTblGuidRight" );
3623	····}
3624	····[Test]
3625	····public void HasMappingTable()
3626	····{
3627	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
3628	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
3629	····}
3630	····[Test]
3631	····public void HasTypeColumn()
3632	····{
3633	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3634	····}
3635	····[Test]
3636	····public void HasTypeCode()
3637	····{
3638	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3639	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3640	····}
3641	}
3642
3643
3644	[TestFixture]
3645	public class MappingTestCmpBi1nTblGuid : NDOTest
3646	{
3647	····PersistenceManager pm;
3648	····NDOMapping mapping;
3649	····Class ownClass;
3650	····Class otherClass;
3651	····[SetUp]
3652	····public void Setup()
3653	····{
3654	········this.pm = PmFactory.NewPersistenceManager();
3655	········this.mapping = pm.NDOMapping;
3656	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nTblGuidLeft" );
3657	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nTblGuidRight" );
3658	····}
3659	····[Test]
3660	····public void HasMappingTable()
3661	····{
3662	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
3663	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
3664	····}
3665	····[Test]
3666	····public void HasTypeColumn()
3667	····{
3668	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3669	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
3670	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
3671	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
3672	····}
3673	····[Test]
3674	····public void HasTypeCode()
3675	····{
3676	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3677	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3678	····}
3679	}
3680
3681
3682	[TestFixture]
3683	public class MappingTestCmpBinnTblGuid : NDOTest
3684	{
3685	····PersistenceManager pm;
3686	····NDOMapping mapping;
3687	····Class ownClass;
3688	····Class otherClass;
3689	····[SetUp]
3690	····public void Setup()
3691	····{
3692	········this.pm = PmFactory.NewPersistenceManager();
3693	········this.mapping = pm.NDOMapping;
3694	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnTblGuidLeft" );
3695	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnTblGuidRight" );
3696	····}
3697	····[Test]
3698	····public void HasMappingTable()
3699	····{
3700	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
3701	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
3702	····}
3703	····[Test]
3704	····public void HasTypeColumn()
3705	····{
3706	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3707	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
3708	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
3709	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
3710	····}
3711	····[Test]
3712	····public void HasTypeCode()
3713	····{
3714	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3715	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3716	····}
3717	}
3718
3719
3720	[TestFixture]
3721	public class MappingTestAgrDir1OwnpconNoTblGuid : NDOTest
3722	{
3723	····PersistenceManager pm;
3724	····NDOMapping mapping;
3725	····Class ownClass;
3726	····Class otherClass;
3727	····Class ownDerivedClass;
3728	····[SetUp]
3729	····public void Setup()
3730	····{
3731	········this.pm = PmFactory.NewPersistenceManager();
3732	········this.mapping = pm.NDOMapping;
3733	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconNoTblGuidLeftBase" );
3734	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconNoTblGuidRight" );
3735	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconNoTblGuidLeftDerived" );
3736	····}
3737	····[Test]
3738	····public void HasMappingTable()
3739	····{
3740	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
3741	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
3742	····}
3743	····[Test]
3744	····public void HasTypeColumn()
3745	····{
3746	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3747	····}
3748	····[Test]
3749	····public void HasTypeCode()
3750	····{
3751	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3752	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3753	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
3754	····}
3755	}
3756
3757
3758	[TestFixture]
3759	public class MappingTestAgrDir1OwnpconTblGuid : NDOTest
3760	{
3761	····PersistenceManager pm;
3762	····NDOMapping mapping;
3763	····Class ownClass;
3764	····Class otherClass;
3765	····Class ownDerivedClass;
3766	····[SetUp]
3767	····public void Setup()
3768	····{
3769	········this.pm = PmFactory.NewPersistenceManager();
3770	········this.mapping = pm.NDOMapping;
3771	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconTblGuidLeftBase" );
3772	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconTblGuidRight" );
3773	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconTblGuidLeftDerived" );
3774	····}
3775	····[Test]
3776	····public void HasMappingTable()
3777	····{
3778	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
3779	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
3780	····}
3781	····[Test]
3782	····public void HasTypeColumn()
3783	····{
3784	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
3785	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
3786	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
3787	····}
3788	····[Test]
3789	····public void HasTypeCode()
3790	····{
3791	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3792	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3793	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
3794	····}
3795	}
3796
3797
3798	[TestFixture]
3799	public class MappingTestAgrBi11OwnpconNoTblGuid : NDOTest
3800	{
3801	····PersistenceManager pm;
3802	····NDOMapping mapping;
3803	····Class ownClass;
3804	····Class otherClass;
3805	····Class ownDerivedClass;
3806	····[SetUp]
3807	····public void Setup()
3808	····{
3809	········this.pm = PmFactory.NewPersistenceManager();
3810	········this.mapping = pm.NDOMapping;
3811	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconNoTblGuidLeftBase" );
3812	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconNoTblGuidRight" );
3813	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconNoTblGuidLeftDerived" );
3814	····}
3815	····[Test]
3816	····public void HasMappingTable()
3817	····{
3818	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
3819	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
3820	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
3821	····}
3822	····[Test]
3823	····public void HasTypeColumn()
3824	····{
3825	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3826	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #10");
3827	····}
3828	····[Test]
3829	····public void HasTypeCode()
3830	····{
3831	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3832	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3833	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
3834	····}
3835	}
3836
3837
3838	[TestFixture]
3839	public class MappingTestAgrBi11OwnpconTblGuid : NDOTest
3840	{
3841	····PersistenceManager pm;
3842	····NDOMapping mapping;
3843	····Class ownClass;
3844	····Class otherClass;
3845	····Class ownDerivedClass;
3846	····[SetUp]
3847	····public void Setup()
3848	····{
3849	········this.pm = PmFactory.NewPersistenceManager();
3850	········this.mapping = pm.NDOMapping;
3851	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconTblGuidLeftBase" );
3852	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconTblGuidRight" );
3853	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconTblGuidLeftDerived" );
3854	····}
3855	····[Test]
3856	····public void HasMappingTable()
3857	····{
3858	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
3859	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
3860	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
3861	····}
3862	····[Test]
3863	····public void HasTypeColumn()
3864	····{
3865	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
3866	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
3867	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
3868	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
3869	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
3870	····}
3871	····[Test]
3872	····public void HasTypeCode()
3873	····{
3874	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3875	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3876	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
3877	····}
3878	}
3879
3880
3881	[TestFixture]
3882	public class MappingTestAgrDirnOwnpconNoTblGuid : NDOTest
3883	{
3884	····PersistenceManager pm;
3885	····NDOMapping mapping;
3886	····Class ownClass;
3887	····Class otherClass;
3888	····Class ownDerivedClass;
3889	····[SetUp]
3890	····public void Setup()
3891	····{
3892	········this.pm = PmFactory.NewPersistenceManager();
3893	········this.mapping = pm.NDOMapping;
3894	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconNoTblGuidLeftBase" );
3895	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconNoTblGuidRight" );
3896	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconNoTblGuidLeftDerived" );
3897	····}
3898	····[Test]
3899	····public void HasMappingTable()
3900	····{
3901	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
3902	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
3903	····}
3904	····[Test]
3905	····public void HasTypeColumn()
3906	····{
3907	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3908	····}
3909	····[Test]
3910	····public void HasTypeCode()
3911	····{
3912	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3913	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3914	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
3915	····}
3916	}
3917
3918
3919	[TestFixture]
3920	public class MappingTestAgrDirnOwnpconTblGuid : NDOTest
3921	{
3922	····PersistenceManager pm;
3923	····NDOMapping mapping;
3924	····Class ownClass;
3925	····Class otherClass;
3926	····Class ownDerivedClass;
3927	····[SetUp]
3928	····public void Setup()
3929	····{
3930	········this.pm = PmFactory.NewPersistenceManager();
3931	········this.mapping = pm.NDOMapping;
3932	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconTblGuidLeftBase" );
3933	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconTblGuidRight" );
3934	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconTblGuidLeftDerived" );
3935	····}
3936	····[Test]
3937	····public void HasMappingTable()
3938	····{
3939	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
3940	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
3941	····}
3942	····[Test]
3943	····public void HasTypeColumn()
3944	····{
3945	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
3946	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
3947	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
3948	····}
3949	····[Test]
3950	····public void HasTypeCode()
3951	····{
3952	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3953	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3954	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
3955	····}
3956	}
3957
3958
3959	[TestFixture]
3960	public class MappingTestAgrBin1OwnpconNoTblGuid : NDOTest
3961	{
3962	····PersistenceManager pm;
3963	····NDOMapping mapping;
3964	····Class ownClass;
3965	····Class otherClass;
3966	····Class ownDerivedClass;
3967	····[SetUp]
3968	····public void Setup()
3969	····{
3970	········this.pm = PmFactory.NewPersistenceManager();
3971	········this.mapping = pm.NDOMapping;
3972	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconNoTblGuidLeftBase" );
3973	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconNoTblGuidRight" );
3974	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconNoTblGuidLeftDerived" );
3975	····}
3976	····[Test]
3977	····public void HasMappingTable()
3978	····{
3979	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
3980	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
3981	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
3982	····}
3983	····[Test]
3984	····public void HasTypeColumn()
3985	····{
3986	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3987	····}
3988	····[Test]
3989	····public void HasTypeCode()
3990	····{
3991	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3992	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3993	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
3994	····}
3995	}
3996
3997
3998	[TestFixture]
3999	public class MappingTestAgrBin1OwnpconTblGuid : NDOTest
4000	{
4001	····PersistenceManager pm;
4002	····NDOMapping mapping;
4003	····Class ownClass;
4004	····Class otherClass;
4005	····Class ownDerivedClass;
4006	····[SetUp]
4007	····public void Setup()
4008	····{
4009	········this.pm = PmFactory.NewPersistenceManager();
4010	········this.mapping = pm.NDOMapping;
4011	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconTblGuidLeftBase" );
4012	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconTblGuidRight" );
4013	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconTblGuidLeftDerived" );
4014	····}
4015	····[Test]
4016	····public void HasMappingTable()
4017	····{
4018	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
4019	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
4020	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
4021	····}
4022	····[Test]
4023	····public void HasTypeColumn()
4024	····{
4025	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
4026	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
4027	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
4028	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
4029	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
4030	····}
4031	····[Test]
4032	····public void HasTypeCode()
4033	····{
4034	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4035	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4036	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4037	····}
4038	}
4039
4040
4041	[TestFixture]
4042	public class MappingTestAgrBi1nOwnpconTblGuid : NDOTest
4043	{
4044	····PersistenceManager pm;
4045	····NDOMapping mapping;
4046	····Class ownClass;
4047	····Class otherClass;
4048	····Class ownDerivedClass;
4049	····[SetUp]
4050	····public void Setup()
4051	····{
4052	········this.pm = PmFactory.NewPersistenceManager();
4053	········this.mapping = pm.NDOMapping;
4054	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconTblGuidLeftBase" );
4055	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconTblGuidRight" );
4056	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconTblGuidLeftDerived" );
4057	····}
4058	····[Test]
4059	····public void HasMappingTable()
4060	····{
4061	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
4062	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
4063	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
4064	····}
4065	····[Test]
4066	····public void HasTypeColumn()
4067	····{
4068	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
4069	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
4070	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
4071	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
4072	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
4073	····}
4074	····[Test]
4075	····public void HasTypeCode()
4076	····{
4077	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4078	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4079	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4080	····}
4081	}
4082
4083
4084	[TestFixture]
4085	public class MappingTestAgrBinnOwnpconTblGuid : NDOTest
4086	{
4087	····PersistenceManager pm;
4088	····NDOMapping mapping;
4089	····Class ownClass;
4090	····Class otherClass;
4091	····Class ownDerivedClass;
4092	····[SetUp]
4093	····public void Setup()
4094	····{
4095	········this.pm = PmFactory.NewPersistenceManager();
4096	········this.mapping = pm.NDOMapping;
4097	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconTblGuidLeftBase" );
4098	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconTblGuidRight" );
4099	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconTblGuidLeftDerived" );
4100	····}
4101	····[Test]
4102	····public void HasMappingTable()
4103	····{
4104	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
4105	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
4106	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
4107	····}
4108	····[Test]
4109	····public void HasTypeColumn()
4110	····{
4111	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
4112	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
4113	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
4114	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
4115	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
4116	····}
4117	····[Test]
4118	····public void HasTypeCode()
4119	····{
4120	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4121	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4122	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4123	····}
4124	}
4125
4126
4127	[TestFixture]
4128	public class MappingTestCmpDir1OwnpconNoTblGuid : NDOTest
4129	{
4130	····PersistenceManager pm;
4131	····NDOMapping mapping;
4132	····Class ownClass;
4133	····Class otherClass;
4134	····Class ownDerivedClass;
4135	····[SetUp]
4136	····public void Setup()
4137	····{
4138	········this.pm = PmFactory.NewPersistenceManager();
4139	········this.mapping = pm.NDOMapping;
4140	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconNoTblGuidLeftBase" );
4141	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconNoTblGuidRight" );
4142	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconNoTblGuidLeftDerived" );
4143	····}
4144	····[Test]
4145	····public void HasMappingTable()
4146	····{
4147	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
4148	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
4149	····}
4150	····[Test]
4151	····public void HasTypeColumn()
4152	····{
4153	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
4154	····}
4155	····[Test]
4156	····public void HasTypeCode()
4157	····{
4158	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4159	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4160	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4161	····}
4162	}
4163
4164
4165	[TestFixture]
4166	public class MappingTestCmpDir1OwnpconTblGuid : NDOTest
4167	{
4168	····PersistenceManager pm;
4169	····NDOMapping mapping;
4170	····Class ownClass;
4171	····Class otherClass;
4172	····Class ownDerivedClass;
4173	····[SetUp]
4174	····public void Setup()
4175	····{
4176	········this.pm = PmFactory.NewPersistenceManager();
4177	········this.mapping = pm.NDOMapping;
4178	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconTblGuidLeftBase" );
4179	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconTblGuidRight" );
4180	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconTblGuidLeftDerived" );
4181	····}
4182	····[Test]
4183	····public void HasMappingTable()
4184	····{
4185	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
4186	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
4187	····}
4188	····[Test]
4189	····public void HasTypeColumn()
4190	····{
4191	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
4192	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
4193	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
4194	····}
4195	····[Test]
4196	····public void HasTypeCode()
4197	····{
4198	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4199	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4200	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4201	····}
4202	}
4203
4204
4205	[TestFixture]
4206	public class MappingTestCmpBi11OwnpconNoTblGuid : NDOTest
4207	{
4208	····PersistenceManager pm;
4209	····NDOMapping mapping;
4210	····Class ownClass;
4211	····Class otherClass;
4212	····Class ownDerivedClass;
4213	····[SetUp]
4214	····public void Setup()
4215	····{
4216	········this.pm = PmFactory.NewPersistenceManager();
4217	········this.mapping = pm.NDOMapping;
4218	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconNoTblGuidLeftBase" );
4219	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconNoTblGuidRight" );
4220	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconNoTblGuidLeftDerived" );
4221	····}
4222	····[Test]
4223	····public void HasMappingTable()
4224	····{
4225	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
4226	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
4227	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
4228	····}
4229	····[Test]
4230	····public void HasTypeColumn()
4231	····{
4232	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
4233	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #10");
4234	····}
4235	····[Test]
4236	····public void HasTypeCode()
4237	····{
4238	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4239	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4240	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4241	····}
4242	}
4243
4244
4245	[TestFixture]
4246	public class MappingTestCmpBi11OwnpconTblGuid : NDOTest
4247	{
4248	····PersistenceManager pm;
4249	····NDOMapping mapping;
4250	····Class ownClass;
4251	····Class otherClass;
4252	····Class ownDerivedClass;
4253	····[SetUp]
4254	····public void Setup()
4255	····{
4256	········this.pm = PmFactory.NewPersistenceManager();
4257	········this.mapping = pm.NDOMapping;
4258	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconTblGuidLeftBase" );
4259	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconTblGuidRight" );
4260	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconTblGuidLeftDerived" );
4261	····}
4262	····[Test]
4263	····public void HasMappingTable()
4264	····{
4265	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
4266	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
4267	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
4268	····}
4269	····[Test]
4270	····public void HasTypeColumn()
4271	····{
4272	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
4273	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
4274	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
4275	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
4276	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
4277	····}
4278	····[Test]
4279	····public void HasTypeCode()
4280	····{
4281	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4282	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4283	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4284	····}
4285	}
4286
4287
4288	[TestFixture]
4289	public class MappingTestCmpDirnOwnpconNoTblGuid : NDOTest
4290	{
4291	····PersistenceManager pm;
4292	····NDOMapping mapping;
4293	····Class ownClass;
4294	····Class otherClass;
4295	····Class ownDerivedClass;
4296	····[SetUp]
4297	····public void Setup()
4298	····{
4299	········this.pm = PmFactory.NewPersistenceManager();
4300	········this.mapping = pm.NDOMapping;
4301	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconNoTblGuidLeftBase" );
4302	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconNoTblGuidRight" );
4303	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconNoTblGuidLeftDerived" );
4304	····}
4305	····[Test]
4306	····public void HasMappingTable()
4307	····{
4308	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
4309	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
4310	····}
4311	····[Test]
4312	····public void HasTypeColumn()
4313	····{
4314	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
4315	····}
4316	····[Test]
4317	····public void HasTypeCode()
4318	····{
4319	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4320	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4321	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4322	····}
4323	}
4324
4325
4326	[TestFixture]
4327	public class MappingTestCmpDirnOwnpconTblGuid : NDOTest
4328	{
4329	····PersistenceManager pm;
4330	····NDOMapping mapping;
4331	····Class ownClass;
4332	····Class otherClass;
4333	····Class ownDerivedClass;
4334	····[SetUp]
4335	····public void Setup()
4336	····{
4337	········this.pm = PmFactory.NewPersistenceManager();
4338	········this.mapping = pm.NDOMapping;
4339	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconTblGuidLeftBase" );
4340	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconTblGuidRight" );
4341	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconTblGuidLeftDerived" );
4342	····}
4343	····[Test]
4344	····public void HasMappingTable()
4345	····{
4346	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
4347	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
4348	····}
4349	····[Test]
4350	····public void HasTypeColumn()
4351	····{
4352	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
4353	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
4354	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
4355	····}
4356	····[Test]
4357	····public void HasTypeCode()
4358	····{
4359	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4360	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4361	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4362	····}
4363	}
4364
4365
4366	[TestFixture]
4367	public class MappingTestCmpBin1OwnpconNoTblGuid : NDOTest
4368	{
4369	····PersistenceManager pm;
4370	····NDOMapping mapping;
4371	····Class ownClass;
4372	····Class otherClass;
4373	····Class ownDerivedClass;
4374	····[SetUp]
4375	····public void Setup()
4376	····{
4377	········this.pm = PmFactory.NewPersistenceManager();
4378	········this.mapping = pm.NDOMapping;
4379	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconNoTblGuidLeftBase" );
4380	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconNoTblGuidRight" );
4381	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconNoTblGuidLeftDerived" );
4382	····}
4383	····[Test]
4384	····public void HasMappingTable()
4385	····{
4386	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
4387	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
4388	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
4389	····}
4390	····[Test]
4391	····public void HasTypeColumn()
4392	····{
4393	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
4394	····}
4395	····[Test]
4396	····public void HasTypeCode()
4397	····{
4398	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4399	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4400	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4401	····}
4402	}
4403
4404
4405	[TestFixture]
4406	public class MappingTestCmpBin1OwnpconTblGuid : NDOTest
4407	{
4408	····PersistenceManager pm;
4409	····NDOMapping mapping;
4410	····Class ownClass;
4411	····Class otherClass;
4412	····Class ownDerivedClass;
4413	····[SetUp]
4414	····public void Setup()
4415	····{
4416	········this.pm = PmFactory.NewPersistenceManager();
4417	········this.mapping = pm.NDOMapping;
4418	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconTblGuidLeftBase" );
4419	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconTblGuidRight" );
4420	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconTblGuidLeftDerived" );
4421	····}
4422	····[Test]
4423	····public void HasMappingTable()
4424	····{
4425	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
4426	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
4427	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
4428	····}
4429	····[Test]
4430	····public void HasTypeColumn()
4431	····{
4432	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
4433	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
4434	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
4435	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
4436	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
4437	····}
4438	····[Test]
4439	····public void HasTypeCode()
4440	····{
4441	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4442	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4443	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4444	····}
4445	}
4446
4447
4448	[TestFixture]
4449	public class MappingTestCmpBi1nOwnpconTblGuid : NDOTest
4450	{
4451	····PersistenceManager pm;
4452	····NDOMapping mapping;
4453	····Class ownClass;
4454	····Class otherClass;
4455	····Class ownDerivedClass;
4456	····[SetUp]
4457	····public void Setup()
4458	····{
4459	········this.pm = PmFactory.NewPersistenceManager();
4460	········this.mapping = pm.NDOMapping;
4461	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconTblGuidLeftBase" );
4462	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconTblGuidRight" );
4463	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconTblGuidLeftDerived" );
4464	····}
4465	····[Test]
4466	····public void HasMappingTable()
4467	····{
4468	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
4469	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
4470	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
4471	····}
4472	····[Test]
4473	····public void HasTypeColumn()
4474	····{
4475	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
4476	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
4477	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
4478	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
4479	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
4480	····}
4481	····[Test]
4482	····public void HasTypeCode()
4483	····{
4484	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4485	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4486	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4487	····}
4488	}
4489
4490
4491	[TestFixture]
4492	public class MappingTestCmpBinnOwnpconTblGuid : NDOTest
4493	{
4494	····PersistenceManager pm;
4495	····NDOMapping mapping;
4496	····Class ownClass;
4497	····Class otherClass;
4498	····Class ownDerivedClass;
4499	····[SetUp]
4500	····public void Setup()
4501	····{
4502	········this.pm = PmFactory.NewPersistenceManager();
4503	········this.mapping = pm.NDOMapping;
4504	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconTblGuidLeftBase" );
4505	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconTblGuidRight" );
4506	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconTblGuidLeftDerived" );
4507	····}
4508	····[Test]
4509	····public void HasMappingTable()
4510	····{
4511	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
4512	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
4513	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
4514	····}
4515	····[Test]
4516	····public void HasTypeColumn()
4517	····{
4518	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
4519	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
4520	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
4521	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
4522	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
4523	····}
4524	····[Test]
4525	····public void HasTypeCode()
4526	····{
4527	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4528	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4529	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4530	····}
4531	}
4532
4533
4534	[TestFixture]
4535	public class MappingTestAgrDir1OthpconNoTblGuid : NDOTest
4536	{
4537	····PersistenceManager pm;
4538	····NDOMapping mapping;
4539	····Class ownClass;
4540	····Class otherClass;
4541	····Class otherDerivedClass;
4542	····[SetUp]
4543	····public void Setup()
4544	····{
4545	········this.pm = PmFactory.NewPersistenceManager();
4546	········this.mapping = pm.NDOMapping;
4547	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconNoTblGuidLeft" );
4548	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconNoTblGuidRightBase" );
4549	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconNoTblGuidRightDerived" );
4550	····}
4551	····[Test]
4552	····public void HasMappingTable()
4553	····{
4554	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
4555	····}
4556	····[Test]
4557	····public void HasTypeColumn()
4558	····{
4559	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
4560	····}
4561	····[Test]
4562	····public void HasTypeCode()
4563	····{
4564	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4565	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4566	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4567	····}
4568	}
4569
4570
4571	[TestFixture]
4572	public class MappingTestAgrDir1OthpconTblGuid : NDOTest
4573	{
4574	····PersistenceManager pm;
4575	····NDOMapping mapping;
4576	····Class ownClass;
4577	····Class otherClass;
4578	····Class otherDerivedClass;
4579	····[SetUp]
4580	····public void Setup()
4581	····{
4582	········this.pm = PmFactory.NewPersistenceManager();
4583	········this.mapping = pm.NDOMapping;
4584	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconTblGuidLeft" );
4585	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconTblGuidRightBase" );
4586	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconTblGuidRightDerived" );
4587	····}
4588	····[Test]
4589	····public void HasMappingTable()
4590	····{
4591	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
4592	····}
4593	····[Test]
4594	····public void HasTypeColumn()
4595	····{
4596	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
4597	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
4598	····}
4599	····[Test]
4600	····public void HasTypeCode()
4601	····{
4602	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4603	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4604	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4605	····}
4606	}
4607
4608
4609	[TestFixture]
4610	public class MappingTestAgrBi11OthpconNoTblGuid : NDOTest
4611	{
4612	····PersistenceManager pm;
4613	····NDOMapping mapping;
4614	····Class ownClass;
4615	····Class otherClass;
4616	····Class otherDerivedClass;
4617	····[SetUp]
4618	····public void Setup()
4619	····{
4620	········this.pm = PmFactory.NewPersistenceManager();
4621	········this.mapping = pm.NDOMapping;
4622	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconNoTblGuidLeft" );
4623	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconNoTblGuidRightBase" );
4624	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconNoTblGuidRightDerived" );
4625	····}
4626	····[Test]
4627	····public void HasMappingTable()
4628	····{
4629	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
4630	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
4631	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
4632	····}
4633	····[Test]
4634	····public void HasTypeColumn()
4635	····{
4636	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
4637	····}
4638	····[Test]
4639	····public void HasTypeCode()
4640	····{
4641	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4642	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4643	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4644	····}
4645	}
4646
4647
4648	[TestFixture]
4649	public class MappingTestAgrBi11OthpconTblGuid : NDOTest
4650	{
4651	····PersistenceManager pm;
4652	····NDOMapping mapping;
4653	····Class ownClass;
4654	····Class otherClass;
4655	····Class otherDerivedClass;
4656	····[SetUp]
4657	····public void Setup()
4658	····{
4659	········this.pm = PmFactory.NewPersistenceManager();
4660	········this.mapping = pm.NDOMapping;
4661	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconTblGuidLeft" );
4662	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconTblGuidRightBase" );
4663	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconTblGuidRightDerived" );
4664	····}
4665	····[Test]
4666	····public void HasMappingTable()
4667	····{
4668	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
4669	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
4670	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
4671	····}
4672	····[Test]
4673	····public void HasTypeColumn()
4674	····{
4675	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
4676	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
4677	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
4678	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
4679	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
4680	····}
4681	····[Test]
4682	····public void HasTypeCode()
4683	····{
4684	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4685	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4686	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4687	····}
4688	}
4689
4690
4691	[TestFixture]
4692	public class MappingTestAgrDirnOthpconTblGuid : NDOTest
4693	{
4694	····PersistenceManager pm;
4695	····NDOMapping mapping;
4696	····Class ownClass;
4697	····Class otherClass;
4698	····Class otherDerivedClass;
4699	····[SetUp]
4700	····public void Setup()
4701	····{
4702	········this.pm = PmFactory.NewPersistenceManager();
4703	········this.mapping = pm.NDOMapping;
4704	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpconTblGuidLeft" );
4705	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpconTblGuidRightBase" );
4706	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpconTblGuidRightDerived" );
4707	····}
4708	····[Test]
4709	····public void HasMappingTable()
4710	····{
4711	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
4712	····}
4713	····[Test]
4714	····public void HasTypeColumn()
4715	····{
4716	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
4717	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
4718	····}
4719	····[Test]
4720	····public void HasTypeCode()
4721	····{
4722	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4723	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4724	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4725	····}
4726	}
4727
4728
4729	[TestFixture]
4730	public class MappingTestAgrBin1OthpconTblGuid : NDOTest
4731	{
4732	····PersistenceManager pm;
4733	····NDOMapping mapping;
4734	····Class ownClass;
4735	····Class otherClass;
4736	····Class otherDerivedClass;
4737	····[SetUp]
4738	····public void Setup()
4739	····{
4740	········this.pm = PmFactory.NewPersistenceManager();
4741	········this.mapping = pm.NDOMapping;
4742	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpconTblGuidLeft" );
4743	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpconTblGuidRightBase" );
4744	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpconTblGuidRightDerived" );
4745	····}
4746	····[Test]
4747	····public void HasMappingTable()
4748	····{
4749	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
4750	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
4751	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
4752	····}
4753	····[Test]
4754	····public void HasTypeColumn()
4755	····{
4756	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
4757	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
4758	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
4759	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
4760	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
4761	····}
4762	····[Test]
4763	····public void HasTypeCode()
4764	····{
4765	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4766	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4767	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4768	····}
4769	}
4770
4771
4772	[TestFixture]
4773	public class MappingTestAgrBi1nOthpconNoTblGuid : NDOTest
4774	{
4775	····PersistenceManager pm;
4776	····NDOMapping mapping;
4777	····Class ownClass;
4778	····Class otherClass;
4779	····Class otherDerivedClass;
4780	····[SetUp]
4781	····public void Setup()
4782	····{
4783	········this.pm = PmFactory.NewPersistenceManager();
4784	········this.mapping = pm.NDOMapping;
4785	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconNoTblGuidLeft" );
4786	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconNoTblGuidRightBase" );
4787	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconNoTblGuidRightDerived" );
4788	····}
4789	····[Test]
4790	····public void HasMappingTable()
4791	····{
4792	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
4793	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
4794	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
4795	····}
4796	····[Test]
4797	····public void HasTypeColumn()
4798	····{
4799	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
4800	····}
4801	····[Test]
4802	····public void HasTypeCode()
4803	····{
4804	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4805	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4806	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4807	····}
4808	}
4809
4810
4811	[TestFixture]
4812	public class MappingTestAgrBi1nOthpconTblGuid : NDOTest
4813	{
4814	····PersistenceManager pm;
4815	····NDOMapping mapping;
4816	····Class ownClass;
4817	····Class otherClass;
4818	····Class otherDerivedClass;
4819	····[SetUp]
4820	····public void Setup()
4821	····{
4822	········this.pm = PmFactory.NewPersistenceManager();
4823	········this.mapping = pm.NDOMapping;
4824	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconTblGuidLeft" );
4825	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconTblGuidRightBase" );
4826	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconTblGuidRightDerived" );
4827	····}
4828	····[Test]
4829	····public void HasMappingTable()
4830	····{
4831	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
4832	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
4833	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
4834	····}
4835	····[Test]
4836	····public void HasTypeColumn()
4837	····{
4838	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
4839	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
4840	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
4841	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
4842	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
4843	····}
4844	····[Test]
4845	····public void HasTypeCode()
4846	····{
4847	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4848	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4849	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4850	····}
4851	}
4852
4853
4854	[TestFixture]
4855	public class MappingTestAgrBinnOthpconTblGuid : NDOTest
4856	{
4857	····PersistenceManager pm;
4858	····NDOMapping mapping;
4859	····Class ownClass;
4860	····Class otherClass;
4861	····Class otherDerivedClass;
4862	····[SetUp]
4863	····public void Setup()
4864	····{
4865	········this.pm = PmFactory.NewPersistenceManager();
4866	········this.mapping = pm.NDOMapping;
4867	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpconTblGuidLeft" );
4868	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpconTblGuidRightBase" );
4869	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpconTblGuidRightDerived" );
4870	····}
4871	····[Test]
4872	····public void HasMappingTable()
4873	····{
4874	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
4875	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
4876	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
4877	····}
4878	····[Test]
4879	····public void HasTypeColumn()
4880	····{
4881	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
4882	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
4883	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
4884	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
4885	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
4886	····}
4887	····[Test]
4888	····public void HasTypeCode()
4889	····{
4890	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4891	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4892	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4893	····}
4894	}
4895
4896
4897	[TestFixture]
4898	public class MappingTestCmpDir1OthpconNoTblGuid : NDOTest
4899	{
4900	····PersistenceManager pm;
4901	····NDOMapping mapping;
4902	····Class ownClass;
4903	····Class otherClass;
4904	····Class otherDerivedClass;
4905	····[SetUp]
4906	····public void Setup()
4907	····{
4908	········this.pm = PmFactory.NewPersistenceManager();
4909	········this.mapping = pm.NDOMapping;
4910	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconNoTblGuidLeft" );
4911	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconNoTblGuidRightBase" );
4912	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconNoTblGuidRightDerived" );
4913	····}
4914	····[Test]
4915	····public void HasMappingTable()
4916	····{
4917	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
4918	····}
4919	····[Test]
4920	····public void HasTypeColumn()
4921	····{
4922	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
4923	····}
4924	····[Test]
4925	····public void HasTypeCode()
4926	····{
4927	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4928	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4929	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4930	····}
4931	}
4932
4933
4934	[TestFixture]
4935	public class MappingTestCmpDir1OthpconTblGuid : NDOTest
4936	{
4937	····PersistenceManager pm;
4938	····NDOMapping mapping;
4939	····Class ownClass;
4940	····Class otherClass;
4941	····Class otherDerivedClass;
4942	····[SetUp]
4943	····public void Setup()
4944	····{
4945	········this.pm = PmFactory.NewPersistenceManager();
4946	········this.mapping = pm.NDOMapping;
4947	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconTblGuidLeft" );
4948	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconTblGuidRightBase" );
4949	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconTblGuidRightDerived" );
4950	····}
4951	····[Test]
4952	····public void HasMappingTable()
4953	····{
4954	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
4955	····}
4956	····[Test]
4957	····public void HasTypeColumn()
4958	····{
4959	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
4960	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
4961	····}
4962	····[Test]
4963	····public void HasTypeCode()
4964	····{
4965	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4966	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4967	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4968	····}
4969	}
4970
4971
4972	[TestFixture]
4973	public class MappingTestCmpBi11OthpconNoTblGuid : NDOTest
4974	{
4975	····PersistenceManager pm;
4976	····NDOMapping mapping;
4977	····Class ownClass;
4978	····Class otherClass;
4979	····Class otherDerivedClass;
4980	····[SetUp]
4981	····public void Setup()
4982	····{
4983	········this.pm = PmFactory.NewPersistenceManager();
4984	········this.mapping = pm.NDOMapping;
4985	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconNoTblGuidLeft" );
4986	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconNoTblGuidRightBase" );
4987	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconNoTblGuidRightDerived" );
4988	····}
4989	····[Test]
4990	····public void HasMappingTable()
4991	····{
4992	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
4993	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
4994	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
4995	····}
4996	····[Test]
4997	····public void HasTypeColumn()
4998	····{
4999	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
5000	····}
5001	····[Test]
5002	····public void HasTypeCode()
5003	····{
5004	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5005	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5006	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5007	····}
5008	}
5009
5010
5011	[TestFixture]
5012	public class MappingTestCmpBi11OthpconTblGuid : NDOTest
5013	{
5014	····PersistenceManager pm;
5015	····NDOMapping mapping;
5016	····Class ownClass;
5017	····Class otherClass;
5018	····Class otherDerivedClass;
5019	····[SetUp]
5020	····public void Setup()
5021	····{
5022	········this.pm = PmFactory.NewPersistenceManager();
5023	········this.mapping = pm.NDOMapping;
5024	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconTblGuidLeft" );
5025	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconTblGuidRightBase" );
5026	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconTblGuidRightDerived" );
5027	····}
5028	····[Test]
5029	····public void HasMappingTable()
5030	····{
5031	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
5032	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
5033	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
5034	····}
5035	····[Test]
5036	····public void HasTypeColumn()
5037	····{
5038	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
5039	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
5040	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
5041	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
5042	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
5043	····}
5044	····[Test]
5045	····public void HasTypeCode()
5046	····{
5047	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5048	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5049	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5050	····}
5051	}
5052
5053
5054	[TestFixture]
5055	public class MappingTestCmpDirnOthpconTblGuid : NDOTest
5056	{
5057	····PersistenceManager pm;
5058	····NDOMapping mapping;
5059	····Class ownClass;
5060	····Class otherClass;
5061	····Class otherDerivedClass;
5062	····[SetUp]
5063	····public void Setup()
5064	····{
5065	········this.pm = PmFactory.NewPersistenceManager();
5066	········this.mapping = pm.NDOMapping;
5067	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpconTblGuidLeft" );
5068	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpconTblGuidRightBase" );
5069	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpconTblGuidRightDerived" );
5070	····}
5071	····[Test]
5072	····public void HasMappingTable()
5073	····{
5074	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
5075	····}
5076	····[Test]
5077	····public void HasTypeColumn()
5078	····{
5079	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
5080	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
5081	····}
5082	····[Test]
5083	····public void HasTypeCode()
5084	····{
5085	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5086	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5087	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5088	····}
5089	}
5090
5091
5092	[TestFixture]
5093	public class MappingTestCmpBin1OthpconTblGuid : NDOTest
5094	{
5095	····PersistenceManager pm;
5096	····NDOMapping mapping;
5097	····Class ownClass;
5098	····Class otherClass;
5099	····Class otherDerivedClass;
5100	····[SetUp]
5101	····public void Setup()
5102	····{
5103	········this.pm = PmFactory.NewPersistenceManager();
5104	········this.mapping = pm.NDOMapping;
5105	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpconTblGuidLeft" );
5106	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpconTblGuidRightBase" );
5107	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpconTblGuidRightDerived" );
5108	····}
5109	····[Test]
5110	····public void HasMappingTable()
5111	····{
5112	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
5113	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
5114	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
5115	····}
5116	····[Test]
5117	····public void HasTypeColumn()
5118	····{
5119	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
5120	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
5121	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
5122	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
5123	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
5124	····}
5125	····[Test]
5126	····public void HasTypeCode()
5127	····{
5128	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5129	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5130	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5131	····}
5132	}
5133
5134
5135	[TestFixture]
5136	public class MappingTestCmpBi1nOthpconNoTblGuid : NDOTest
5137	{
5138	····PersistenceManager pm;
5139	····NDOMapping mapping;
5140	····Class ownClass;
5141	····Class otherClass;
5142	····Class otherDerivedClass;
5143	····[SetUp]
5144	····public void Setup()
5145	····{
5146	········this.pm = PmFactory.NewPersistenceManager();
5147	········this.mapping = pm.NDOMapping;
5148	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconNoTblGuidLeft" );
5149	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconNoTblGuidRightBase" );
5150	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconNoTblGuidRightDerived" );
5151	····}
5152	····[Test]
5153	····public void HasMappingTable()
5154	····{
5155	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
5156	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
5157	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
5158	····}
5159	····[Test]
5160	····public void HasTypeColumn()
5161	····{
5162	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
5163	····}
5164	····[Test]
5165	····public void HasTypeCode()
5166	····{
5167	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5168	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5169	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5170	····}
5171	}
5172
5173
5174	[TestFixture]
5175	public class MappingTestCmpBi1nOthpconTblGuid : NDOTest
5176	{
5177	····PersistenceManager pm;
5178	····NDOMapping mapping;
5179	····Class ownClass;
5180	····Class otherClass;
5181	····Class otherDerivedClass;
5182	····[SetUp]
5183	····public void Setup()
5184	····{
5185	········this.pm = PmFactory.NewPersistenceManager();
5186	········this.mapping = pm.NDOMapping;
5187	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconTblGuidLeft" );
5188	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconTblGuidRightBase" );
5189	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconTblGuidRightDerived" );
5190	····}
5191	····[Test]
5192	····public void HasMappingTable()
5193	····{
5194	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
5195	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
5196	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
5197	····}
5198	····[Test]
5199	····public void HasTypeColumn()
5200	····{
5201	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
5202	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
5203	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
5204	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
5205	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
5206	····}
5207	····[Test]
5208	····public void HasTypeCode()
5209	····{
5210	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5211	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5212	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5213	····}
5214	}
5215
5216
5217	[TestFixture]
5218	public class MappingTestCmpBinnOthpconTblGuid : NDOTest
5219	{
5220	····PersistenceManager pm;
5221	····NDOMapping mapping;
5222	····Class ownClass;
5223	····Class otherClass;
5224	····Class otherDerivedClass;
5225	····[SetUp]
5226	····public void Setup()
5227	····{
5228	········this.pm = PmFactory.NewPersistenceManager();
5229	········this.mapping = pm.NDOMapping;
5230	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpconTblGuidLeft" );
5231	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpconTblGuidRightBase" );
5232	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpconTblGuidRightDerived" );
5233	····}
5234	····[Test]
5235	····public void HasMappingTable()
5236	····{
5237	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
5238	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
5239	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
5240	····}
5241	····[Test]
5242	····public void HasTypeColumn()
5243	····{
5244	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
5245	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
5246	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
5247	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
5248	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
5249	····}
5250	····[Test]
5251	····public void HasTypeCode()
5252	····{
5253	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5254	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5255	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5256	····}
5257	}
5258
5259
5260	[TestFixture]
5261	public class MappingTestAgrDir1OwnpconOthpconNoTblGuid : NDOTest
5262	{
5263	····PersistenceManager pm;
5264	····NDOMapping mapping;
5265	····Class ownClass;
5266	····Class otherClass;
5267	····Class ownDerivedClass;
5268	····Class otherDerivedClass;
5269	····[SetUp]
5270	····public void Setup()
5271	····{
5272	········this.pm = PmFactory.NewPersistenceManager();
5273	········this.mapping = pm.NDOMapping;
5274	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconNoTblGuidLeftBase" );
5275	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconNoTblGuidRightBase" );
5276	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconNoTblGuidLeftDerived" );
5277	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconNoTblGuidRightDerived" );
5278	····}
5279	····[Test]
5280	····public void HasMappingTable()
5281	····{
5282	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
5283	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
5284	····}
5285	····[Test]
5286	····public void HasTypeColumn()
5287	····{
5288	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
5289	····}
5290	····[Test]
5291	····public void HasTypeCode()
5292	····{
5293	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5294	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5295	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5296	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5297	····}
5298	}
5299
5300
5301	[TestFixture]
5302	public class MappingTestAgrDir1OwnpconOthpconTblGuid : NDOTest
5303	{
5304	····PersistenceManager pm;
5305	····NDOMapping mapping;
5306	····Class ownClass;
5307	····Class otherClass;
5308	····Class ownDerivedClass;
5309	····Class otherDerivedClass;
5310	····[SetUp]
5311	····public void Setup()
5312	····{
5313	········this.pm = PmFactory.NewPersistenceManager();
5314	········this.mapping = pm.NDOMapping;
5315	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconTblGuidLeftBase" );
5316	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconTblGuidRightBase" );
5317	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconTblGuidLeftDerived" );
5318	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconTblGuidRightDerived" );
5319	····}
5320	····[Test]
5321	····public void HasMappingTable()
5322	····{
5323	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
5324	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
5325	····}
5326	····[Test]
5327	····public void HasTypeColumn()
5328	····{
5329	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
5330	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
5331	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
5332	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
5333	····}
5334	····[Test]
5335	····public void HasTypeCode()
5336	····{
5337	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5338	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5339	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5340	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5341	····}
5342	}
5343
5344
5345	[TestFixture]
5346	public class MappingTestAgrBi11OwnpconOthpconNoTblGuid : NDOTest
5347	{
5348	····PersistenceManager pm;
5349	····NDOMapping mapping;
5350	····Class ownClass;
5351	····Class otherClass;
5352	····Class ownDerivedClass;
5353	····Class otherDerivedClass;
5354	····[SetUp]
5355	····public void Setup()
5356	····{
5357	········this.pm = PmFactory.NewPersistenceManager();
5358	········this.mapping = pm.NDOMapping;
5359	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconNoTblGuidLeftBase" );
5360	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconNoTblGuidRightBase" );
5361	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconNoTblGuidLeftDerived" );
5362	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconNoTblGuidRightDerived" );
5363	····}
5364	····[Test]
5365	····public void HasMappingTable()
5366	····{
5367	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
5368	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
5369	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
5370	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
5371	····}
5372	····[Test]
5373	····public void HasTypeColumn()
5374	····{
5375	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
5376	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #10");
5377	····}
5378	····[Test]
5379	····public void HasTypeCode()
5380	····{
5381	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5382	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5383	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5384	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5385	····}
5386	}
5387
5388
5389	[TestFixture]
5390	public class MappingTestAgrBi11OwnpconOthpconTblGuid : NDOTest
5391	{
5392	····PersistenceManager pm;
5393	····NDOMapping mapping;
5394	····Class ownClass;
5395	····Class otherClass;
5396	····Class ownDerivedClass;
5397	····Class otherDerivedClass;
5398	····[SetUp]
5399	····public void Setup()
5400	····{
5401	········this.pm = PmFactory.NewPersistenceManager();
5402	········this.mapping = pm.NDOMapping;
5403	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconTblGuidLeftBase" );
5404	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconTblGuidRightBase" );
5405	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconTblGuidLeftDerived" );
5406	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconTblGuidRightDerived" );
5407	····}
5408	····[Test]
5409	····public void HasMappingTable()
5410	····{
5411	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
5412	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
5413	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
5414	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
5415	····}
5416	····[Test]
5417	····public void HasTypeColumn()
5418	····{
5419	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
5420	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
5421	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
5422	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
5423	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
5424	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
5425	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
5426	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
5427	····}
5428	····[Test]
5429	····public void HasTypeCode()
5430	····{
5431	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5432	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5433	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5434	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5435	····}
5436	}
5437
5438
5439	[TestFixture]
5440	public class MappingTestAgrDirnOwnpconOthpconTblGuid : NDOTest
5441	{
5442	····PersistenceManager pm;
5443	····NDOMapping mapping;
5444	····Class ownClass;
5445	····Class otherClass;
5446	····Class ownDerivedClass;
5447	····Class otherDerivedClass;
5448	····[SetUp]
5449	····public void Setup()
5450	····{
5451	········this.pm = PmFactory.NewPersistenceManager();
5452	········this.mapping = pm.NDOMapping;
5453	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconOthpconTblGuidLeftBase" );
5454	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconOthpconTblGuidRightBase" );
5455	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconOthpconTblGuidLeftDerived" );
5456	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconOthpconTblGuidRightDerived" );
5457	····}
5458	····[Test]
5459	····public void HasMappingTable()
5460	····{
5461	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
5462	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
5463	····}
5464	····[Test]
5465	····public void HasTypeColumn()
5466	····{
5467	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
5468	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
5469	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
5470	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
5471	····}
5472	····[Test]
5473	····public void HasTypeCode()
5474	····{
5475	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5476	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5477	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5478	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5479	····}
5480	}
5481
5482
5483	[TestFixture]
5484	public class MappingTestAgrBin1OwnpconOthpconTblGuid : NDOTest
5485	{
5486	····PersistenceManager pm;
5487	····NDOMapping mapping;
5488	····Class ownClass;
5489	····Class otherClass;
5490	····Class ownDerivedClass;
5491	····Class otherDerivedClass;
5492	····[SetUp]
5493	····public void Setup()
5494	····{
5495	········this.pm = PmFactory.NewPersistenceManager();
5496	········this.mapping = pm.NDOMapping;
5497	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconOthpconTblGuidLeftBase" );
5498	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconOthpconTblGuidRightBase" );
5499	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconOthpconTblGuidLeftDerived" );
5500	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconOthpconTblGuidRightDerived" );
5501	····}
5502	····[Test]
5503	····public void HasMappingTable()
5504	····{
5505	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
5506	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
5507	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
5508	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
5509	····}
5510	····[Test]
5511	····public void HasTypeColumn()
5512	····{
5513	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
5514	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
5515	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
5516	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
5517	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
5518	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
5519	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
5520	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
5521	····}
5522	····[Test]
5523	····public void HasTypeCode()
5524	····{
5525	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5526	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5527	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5528	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5529	····}
5530	}
5531
5532
5533	[TestFixture]
5534	public class MappingTestAgrBi1nOwnpconOthpconTblGuid : NDOTest
5535	{
5536	····PersistenceManager pm;
5537	····NDOMapping mapping;
5538	····Class ownClass;
5539	····Class otherClass;
5540	····Class ownDerivedClass;
5541	····Class otherDerivedClass;
5542	····[SetUp]
5543	····public void Setup()
5544	····{
5545	········this.pm = PmFactory.NewPersistenceManager();
5546	········this.mapping = pm.NDOMapping;
5547	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconOthpconTblGuidLeftBase" );
5548	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconOthpconTblGuidRightBase" );
5549	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconOthpconTblGuidLeftDerived" );
5550	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconOthpconTblGuidRightDerived" );
5551	····}
5552	····[Test]
5553	····public void HasMappingTable()
5554	····{
5555	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
5556	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
5557	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
5558	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
5559	····}
5560	····[Test]
5561	····public void HasTypeColumn()
5562	····{
5563	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
5564	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
5565	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
5566	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
5567	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
5568	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
5569	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
5570	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
5571	····}
5572	····[Test]
5573	····public void HasTypeCode()
5574	····{
5575	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5576	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5577	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5578	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5579	····}
5580	}
5581
5582
5583	[TestFixture]
5584	public class MappingTestAgrBinnOwnpconOthpconTblGuid : NDOTest
5585	{
5586	····PersistenceManager pm;
5587	····NDOMapping mapping;
5588	····Class ownClass;
5589	····Class otherClass;
5590	····Class ownDerivedClass;
5591	····Class otherDerivedClass;
5592	····[SetUp]
5593	····public void Setup()
5594	····{
5595	········this.pm = PmFactory.NewPersistenceManager();
5596	········this.mapping = pm.NDOMapping;
5597	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconOthpconTblGuidLeftBase" );
5598	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconOthpconTblGuidRightBase" );
5599	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconOthpconTblGuidLeftDerived" );
5600	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconOthpconTblGuidRightDerived" );
5601	····}
5602	····[Test]
5603	····public void HasMappingTable()
5604	····{
5605	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
5606	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
5607	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
5608	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
5609	····}
5610	····[Test]
5611	····public void HasTypeColumn()
5612	····{
5613	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
5614	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
5615	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
5616	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
5617	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
5618	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
5619	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
5620	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
5621	····}
5622	····[Test]
5623	····public void HasTypeCode()
5624	····{
5625	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5626	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5627	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5628	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5629	····}
5630	}
5631
5632
5633	[TestFixture]
5634	public class MappingTestCmpDir1OwnpconOthpconNoTblGuid : NDOTest
5635	{
5636	····PersistenceManager pm;
5637	····NDOMapping mapping;
5638	····Class ownClass;
5639	····Class otherClass;
5640	····Class ownDerivedClass;
5641	····Class otherDerivedClass;
5642	····[SetUp]
5643	····public void Setup()
5644	····{
5645	········this.pm = PmFactory.NewPersistenceManager();
5646	········this.mapping = pm.NDOMapping;
5647	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconNoTblGuidLeftBase" );
5648	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconNoTblGuidRightBase" );
5649	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconNoTblGuidLeftDerived" );
5650	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconNoTblGuidRightDerived" );
5651	····}
5652	····[Test]
5653	····public void HasMappingTable()
5654	····{
5655	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
5656	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
5657	····}
5658	····[Test]
5659	····public void HasTypeColumn()
5660	····{
5661	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
5662	····}
5663	····[Test]
5664	····public void HasTypeCode()
5665	····{
5666	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5667	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5668	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5669	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5670	····}
5671	}
5672
5673
5674	[TestFixture]
5675	public class MappingTestCmpDir1OwnpconOthpconTblGuid : NDOTest
5676	{
5677	····PersistenceManager pm;
5678	····NDOMapping mapping;
5679	····Class ownClass;
5680	····Class otherClass;
5681	····Class ownDerivedClass;
5682	····Class otherDerivedClass;
5683	····[SetUp]
5684	····public void Setup()
5685	····{
5686	········this.pm = PmFactory.NewPersistenceManager();
5687	········this.mapping = pm.NDOMapping;
5688	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconTblGuidLeftBase" );
5689	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconTblGuidRightBase" );
5690	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconTblGuidLeftDerived" );
5691	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconTblGuidRightDerived" );
5692	····}
5693	····[Test]
5694	····public void HasMappingTable()
5695	····{
5696	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
5697	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
5698	····}
5699	····[Test]
5700	····public void HasTypeColumn()
5701	····{
5702	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
5703	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
5704	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
5705	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
5706	····}
5707	····[Test]
5708	····public void HasTypeCode()
5709	····{
5710	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5711	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5712	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5713	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5714	····}
5715	}
5716
5717
5718	[TestFixture]
5719	public class MappingTestCmpBi11OwnpconOthpconNoTblGuid : NDOTest
5720	{
5721	····PersistenceManager pm;
5722	····NDOMapping mapping;
5723	····Class ownClass;
5724	····Class otherClass;
5725	····Class ownDerivedClass;
5726	····Class otherDerivedClass;
5727	····[SetUp]
5728	····public void Setup()
5729	····{
5730	········this.pm = PmFactory.NewPersistenceManager();
5731	········this.mapping = pm.NDOMapping;
5732	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconNoTblGuidLeftBase" );
5733	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconNoTblGuidRightBase" );
5734	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconNoTblGuidLeftDerived" );
5735	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconNoTblGuidRightDerived" );
5736	····}
5737	····[Test]
5738	····public void HasMappingTable()
5739	····{
5740	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
5741	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
5742	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
5743	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
5744	····}
5745	····[Test]
5746	····public void HasTypeColumn()
5747	····{
5748	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
5749	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #10");
5750	····}
5751	····[Test]
5752	····public void HasTypeCode()
5753	····{
5754	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5755	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5756	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5757	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5758	····}
5759	}
5760
5761
5762	[TestFixture]
5763	public class MappingTestCmpBi11OwnpconOthpconTblGuid : NDOTest
5764	{
5765	····PersistenceManager pm;
5766	····NDOMapping mapping;
5767	····Class ownClass;
5768	····Class otherClass;
5769	····Class ownDerivedClass;
5770	····Class otherDerivedClass;
5771	····[SetUp]
5772	····public void Setup()
5773	····{
5774	········this.pm = PmFactory.NewPersistenceManager();
5775	········this.mapping = pm.NDOMapping;
5776	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconTblGuidLeftBase" );
5777	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconTblGuidRightBase" );
5778	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconTblGuidLeftDerived" );
5779	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconTblGuidRightDerived" );
5780	····}
5781	····[Test]
5782	····public void HasMappingTable()
5783	····{
5784	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
5785	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
5786	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
5787	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
5788	····}
5789	····[Test]
5790	····public void HasTypeColumn()
5791	····{
5792	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
5793	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
5794	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
5795	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
5796	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
5797	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
5798	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
5799	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
5800	····}
5801	····[Test]
5802	····public void HasTypeCode()
5803	····{
5804	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5805	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5806	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5807	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5808	····}
5809	}
5810
5811
5812	[TestFixture]
5813	public class MappingTestCmpDirnOwnpconOthpconTblGuid : NDOTest
5814	{
5815	····PersistenceManager pm;
5816	····NDOMapping mapping;
5817	····Class ownClass;
5818	····Class otherClass;
5819	····Class ownDerivedClass;
5820	····Class otherDerivedClass;
5821	····[SetUp]
5822	····public void Setup()
5823	····{
5824	········this.pm = PmFactory.NewPersistenceManager();
5825	········this.mapping = pm.NDOMapping;
5826	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconOthpconTblGuidLeftBase" );
5827	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconOthpconTblGuidRightBase" );
5828	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconOthpconTblGuidLeftDerived" );
5829	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconOthpconTblGuidRightDerived" );
5830	····}
5831	····[Test]
5832	····public void HasMappingTable()
5833	····{
5834	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
5835	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
5836	····}
5837	····[Test]
5838	····public void HasTypeColumn()
5839	····{
5840	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
5841	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
5842	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
5843	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
5844	····}
5845	····[Test]
5846	····public void HasTypeCode()
5847	····{
5848	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5849	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5850	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5851	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5852	····}
5853	}
5854
5855
5856	[TestFixture]
5857	public class MappingTestCmpBin1OwnpconOthpconTblGuid : NDOTest
5858	{
5859	····PersistenceManager pm;
5860	····NDOMapping mapping;
5861	····Class ownClass;
5862	····Class otherClass;
5863	····Class ownDerivedClass;
5864	····Class otherDerivedClass;
5865	····[SetUp]
5866	····public void Setup()
5867	····{
5868	········this.pm = PmFactory.NewPersistenceManager();
5869	········this.mapping = pm.NDOMapping;
5870	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconOthpconTblGuidLeftBase" );
5871	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconOthpconTblGuidRightBase" );
5872	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconOthpconTblGuidLeftDerived" );
5873	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconOthpconTblGuidRightDerived" );
5874	····}
5875	····[Test]
5876	····public void HasMappingTable()
5877	····{
5878	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
5879	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
5880	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
5881	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
5882	····}
5883	····[Test]
5884	····public void HasTypeColumn()
5885	····{
5886	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
5887	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
5888	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
5889	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
5890	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
5891	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
5892	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
5893	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
5894	····}
5895	····[Test]
5896	····public void HasTypeCode()
5897	····{
5898	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5899	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5900	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5901	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5902	····}
5903	}
5904
5905
5906	[TestFixture]
5907	public class MappingTestCmpBi1nOwnpconOthpconTblGuid : NDOTest
5908	{
5909	····PersistenceManager pm;
5910	····NDOMapping mapping;
5911	····Class ownClass;
5912	····Class otherClass;
5913	····Class ownDerivedClass;
5914	····Class otherDerivedClass;
5915	····[SetUp]
5916	····public void Setup()
5917	····{
5918	········this.pm = PmFactory.NewPersistenceManager();
5919	········this.mapping = pm.NDOMapping;
5920	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconOthpconTblGuidLeftBase" );
5921	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconOthpconTblGuidRightBase" );
5922	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconOthpconTblGuidLeftDerived" );
5923	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconOthpconTblGuidRightDerived" );
5924	····}
5925	····[Test]
5926	····public void HasMappingTable()
5927	····{
5928	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
5929	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
5930	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
5931	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
5932	····}
5933	····[Test]
5934	····public void HasTypeColumn()
5935	····{
5936	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
5937	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
5938	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
5939	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
5940	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
5941	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
5942	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
5943	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
5944	····}
5945	····[Test]
5946	····public void HasTypeCode()
5947	····{
5948	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5949	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5950	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5951	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5952	····}
5953	}
5954
5955
5956	[TestFixture]
5957	public class MappingTestCmpBinnOwnpconOthpconTblGuid : NDOTest
5958	{
5959	····PersistenceManager pm;
5960	····NDOMapping mapping;
5961	····Class ownClass;
5962	····Class otherClass;
5963	····Class ownDerivedClass;
5964	····Class otherDerivedClass;
5965	····[SetUp]
5966	····public void Setup()
5967	····{
5968	········this.pm = PmFactory.NewPersistenceManager();
5969	········this.mapping = pm.NDOMapping;
5970	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconOthpconTblGuidLeftBase" );
5971	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconOthpconTblGuidRightBase" );
5972	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconOthpconTblGuidLeftDerived" );
5973	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconOthpconTblGuidRightDerived" );
5974	····}
5975	····[Test]
5976	····public void HasMappingTable()
5977	····{
5978	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
5979	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
5980	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
5981	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
5982	····}
5983	····[Test]
5984	····public void HasTypeColumn()
5985	····{
5986	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
5987	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
5988	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
5989	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
5990	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
5991	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
5992	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
5993	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
5994	····}
5995	····[Test]
5996	····public void HasTypeCode()
5997	····{
5998	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5999	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6000	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6001	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
6002	····}
6003	}
6004
6005
6006	[TestFixture]
6007	public class MappingTestAgrDir1OwnpabsNoTblAuto : NDOTest
6008	{
6009	····PersistenceManager pm;
6010	····NDOMapping mapping;
6011	····Class ownClass;
6012	····Class otherClass;
6013	····Class ownDerivedClass;
6014	····[SetUp]
6015	····public void Setup()
6016	····{
6017	········this.pm = PmFactory.NewPersistenceManager();
6018	········this.mapping = pm.NDOMapping;
6019	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsNoTblAutoLeftBase" );
6020	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsNoTblAutoRight" );
6021	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsNoTblAutoLeftDerived" );
6022	····}
6023	····[Test]
6024	····public void HasMappingTable()
6025	····{
6026	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
6027	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
6028	····}
6029	····[Test]
6030	····public void HasTypeColumn()
6031	····{
6032	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
6033	····}
6034	····[Test]
6035	····public void HasTypeCode()
6036	····{
6037	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6038	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6039	····}
6040	}
6041
6042
6043	[TestFixture]
6044	public class MappingTestAgrDir1OwnpabsTblAuto : NDOTest
6045	{
6046	····PersistenceManager pm;
6047	····NDOMapping mapping;
6048	····Class ownClass;
6049	····Class otherClass;
6050	····Class ownDerivedClass;
6051	····[SetUp]
6052	····public void Setup()
6053	····{
6054	········this.pm = PmFactory.NewPersistenceManager();
6055	········this.mapping = pm.NDOMapping;
6056	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsTblAutoLeftBase" );
6057	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsTblAutoRight" );
6058	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsTblAutoLeftDerived" );
6059	····}
6060	····[Test]
6061	····public void HasMappingTable()
6062	····{
6063	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
6064	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
6065	····}
6066	····[Test]
6067	····public void HasTypeColumn()
6068	····{
6069	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
6070	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
6071	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
6072	····}
6073	····[Test]
6074	····public void HasTypeCode()
6075	····{
6076	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6077	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6078	····}
6079	}
6080
6081
6082	[TestFixture]
6083	public class MappingTestAgrBi11OwnpabsNoTblAuto : NDOTest
6084	{
6085	····PersistenceManager pm;
6086	····NDOMapping mapping;
6087	····Class ownClass;
6088	····Class otherClass;
6089	····Class ownDerivedClass;
6090	····[SetUp]
6091	····public void Setup()
6092	····{
6093	········this.pm = PmFactory.NewPersistenceManager();
6094	········this.mapping = pm.NDOMapping;
6095	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsNoTblAutoLeftBase" );
6096	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsNoTblAutoRight" );
6097	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsNoTblAutoLeftDerived" );
6098	····}
6099	····[Test]
6100	····public void HasMappingTable()
6101	····{
6102	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
6103	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
6104	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
6105	····}
6106	····[Test]
6107	····public void HasTypeColumn()
6108	····{
6109	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
6110	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #10");
6111	····}
6112	····[Test]
6113	····public void HasTypeCode()
6114	····{
6115	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6116	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6117	····}
6118	}
6119
6120
6121	[TestFixture]
6122	public class MappingTestAgrBi11OwnpabsTblAuto : NDOTest
6123	{
6124	····PersistenceManager pm;
6125	····NDOMapping mapping;
6126	····Class ownClass;
6127	····Class otherClass;
6128	····Class ownDerivedClass;
6129	····[SetUp]
6130	····public void Setup()
6131	····{
6132	········this.pm = PmFactory.NewPersistenceManager();
6133	········this.mapping = pm.NDOMapping;
6134	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsTblAutoLeftBase" );
6135	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsTblAutoRight" );
6136	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsTblAutoLeftDerived" );
6137	····}
6138	····[Test]
6139	····public void HasMappingTable()
6140	····{
6141	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
6142	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
6143	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
6144	····}
6145	····[Test]
6146	····public void HasTypeColumn()
6147	····{
6148	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
6149	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
6150	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
6151	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
6152	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
6153	····}
6154	····[Test]
6155	····public void HasTypeCode()
6156	····{
6157	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6158	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6159	····}
6160	}
6161
6162
6163	[TestFixture]
6164	public class MappingTestAgrDirnOwnpabsNoTblAuto : NDOTest
6165	{
6166	····PersistenceManager pm;
6167	····NDOMapping mapping;
6168	····Class ownClass;
6169	····Class otherClass;
6170	····Class ownDerivedClass;
6171	····[SetUp]
6172	····public void Setup()
6173	····{
6174	········this.pm = PmFactory.NewPersistenceManager();
6175	········this.mapping = pm.NDOMapping;
6176	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsNoTblAutoLeftBase" );
6177	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsNoTblAutoRight" );
6178	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsNoTblAutoLeftDerived" );
6179	····}
6180	····[Test]
6181	····public void HasMappingTable()
6182	····{
6183	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
6184	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
6185	····}
6186	····[Test]
6187	····public void HasTypeColumn()
6188	····{
6189	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
6190	····}
6191	····[Test]
6192	····public void HasTypeCode()
6193	····{
6194	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6195	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6196	····}
6197	}
6198
6199
6200	[TestFixture]
6201	public class MappingTestAgrDirnOwnpabsTblAuto : NDOTest
6202	{
6203	····PersistenceManager pm;
6204	····NDOMapping mapping;
6205	····Class ownClass;
6206	····Class otherClass;
6207	····Class ownDerivedClass;
6208	····[SetUp]
6209	····public void Setup()
6210	····{
6211	········this.pm = PmFactory.NewPersistenceManager();
6212	········this.mapping = pm.NDOMapping;
6213	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsTblAutoLeftBase" );
6214	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsTblAutoRight" );
6215	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsTblAutoLeftDerived" );
6216	····}
6217	····[Test]
6218	····public void HasMappingTable()
6219	····{
6220	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
6221	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
6222	····}
6223	····[Test]
6224	····public void HasTypeColumn()
6225	····{
6226	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
6227	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
6228	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
6229	····}
6230	····[Test]
6231	····public void HasTypeCode()
6232	····{
6233	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6234	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6235	····}
6236	}
6237
6238
6239	[TestFixture]
6240	public class MappingTestAgrBin1OwnpabsNoTblAuto : NDOTest
6241	{
6242	····PersistenceManager pm;
6243	····NDOMapping mapping;
6244	····Class ownClass;
6245	····Class otherClass;
6246	····Class ownDerivedClass;
6247	····[SetUp]
6248	····public void Setup()
6249	····{
6250	········this.pm = PmFactory.NewPersistenceManager();
6251	········this.mapping = pm.NDOMapping;
6252	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsNoTblAutoLeftBase" );
6253	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsNoTblAutoRight" );
6254	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsNoTblAutoLeftDerived" );
6255	····}
6256	····[Test]
6257	····public void HasMappingTable()
6258	····{
6259	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
6260	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
6261	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
6262	····}
6263	····[Test]
6264	····public void HasTypeColumn()
6265	····{
6266	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
6267	····}
6268	····[Test]
6269	····public void HasTypeCode()
6270	····{
6271	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6272	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6273	····}
6274	}
6275
6276
6277	[TestFixture]
6278	public class MappingTestAgrBin1OwnpabsTblAuto : NDOTest
6279	{
6280	····PersistenceManager pm;
6281	····NDOMapping mapping;
6282	····Class ownClass;
6283	····Class otherClass;
6284	····Class ownDerivedClass;
6285	····[SetUp]
6286	····public void Setup()
6287	····{
6288	········this.pm = PmFactory.NewPersistenceManager();
6289	········this.mapping = pm.NDOMapping;
6290	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsTblAutoLeftBase" );
6291	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsTblAutoRight" );
6292	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsTblAutoLeftDerived" );
6293	····}
6294	····[Test]
6295	····public void HasMappingTable()
6296	····{
6297	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
6298	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
6299	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
6300	····}
6301	····[Test]
6302	····public void HasTypeColumn()
6303	····{
6304	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
6305	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
6306	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
6307	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
6308	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
6309	····}
6310	····[Test]
6311	····public void HasTypeCode()
6312	····{
6313	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6314	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6315	····}
6316	}
6317
6318
6319	[TestFixture]
6320	public class MappingTestAgrBi1nOwnpabsTblAuto : NDOTest
6321	{
6322	····PersistenceManager pm;
6323	····NDOMapping mapping;
6324	····Class ownClass;
6325	····Class otherClass;
6326	····Class ownDerivedClass;
6327	····[SetUp]
6328	····public void Setup()
6329	····{
6330	········this.pm = PmFactory.NewPersistenceManager();
6331	········this.mapping = pm.NDOMapping;
6332	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsTblAutoLeftBase" );
6333	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsTblAutoRight" );
6334	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsTblAutoLeftDerived" );
6335	····}
6336	····[Test]
6337	····public void HasMappingTable()
6338	····{
6339	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
6340	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
6341	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
6342	····}
6343	····[Test]
6344	····public void HasTypeColumn()
6345	····{
6346	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
6347	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
6348	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
6349	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
6350	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
6351	····}
6352	····[Test]
6353	····public void HasTypeCode()
6354	····{
6355	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6356	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6357	····}
6358	}
6359
6360
6361	[TestFixture]
6362	public class MappingTestAgrBinnOwnpabsTblAuto : NDOTest
6363	{
6364	····PersistenceManager pm;
6365	····NDOMapping mapping;
6366	····Class ownClass;
6367	····Class otherClass;
6368	····Class ownDerivedClass;
6369	····[SetUp]
6370	····public void Setup()
6371	····{
6372	········this.pm = PmFactory.NewPersistenceManager();
6373	········this.mapping = pm.NDOMapping;
6374	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsTblAutoLeftBase" );
6375	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsTblAutoRight" );
6376	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsTblAutoLeftDerived" );
6377	····}
6378	····[Test]
6379	····public void HasMappingTable()
6380	····{
6381	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
6382	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
6383	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
6384	····}
6385	····[Test]
6386	····public void HasTypeColumn()
6387	····{
6388	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
6389	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
6390	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
6391	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
6392	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
6393	····}
6394	····[Test]
6395	····public void HasTypeCode()
6396	····{
6397	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6398	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6399	····}
6400	}
6401
6402
6403	[TestFixture]
6404	public class MappingTestCmpDir1OwnpabsNoTblAuto : NDOTest
6405	{
6406	····PersistenceManager pm;
6407	····NDOMapping mapping;
6408	····Class ownClass;
6409	····Class otherClass;
6410	····Class ownDerivedClass;
6411	····[SetUp]
6412	····public void Setup()
6413	····{
6414	········this.pm = PmFactory.NewPersistenceManager();
6415	········this.mapping = pm.NDOMapping;
6416	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsNoTblAutoLeftBase" );
6417	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsNoTblAutoRight" );
6418	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsNoTblAutoLeftDerived" );
6419	····}
6420	····[Test]
6421	····public void HasMappingTable()
6422	····{
6423	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
6424	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
6425	····}
6426	····[Test]
6427	····public void HasTypeColumn()
6428	····{
6429	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
6430	····}
6431	····[Test]
6432	····public void HasTypeCode()
6433	····{
6434	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6435	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6436	····}
6437	}
6438
6439
6440	[TestFixture]
6441	public class MappingTestCmpDir1OwnpabsTblAuto : NDOTest
6442	{
6443	····PersistenceManager pm;
6444	····NDOMapping mapping;
6445	····Class ownClass;
6446	····Class otherClass;
6447	····Class ownDerivedClass;
6448	····[SetUp]
6449	····public void Setup()
6450	····{
6451	········this.pm = PmFactory.NewPersistenceManager();
6452	········this.mapping = pm.NDOMapping;
6453	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsTblAutoLeftBase" );
6454	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsTblAutoRight" );
6455	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsTblAutoLeftDerived" );
6456	····}
6457	····[Test]
6458	····public void HasMappingTable()
6459	····{
6460	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
6461	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
6462	····}
6463	····[Test]
6464	····public void HasTypeColumn()
6465	····{
6466	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
6467	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
6468	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
6469	····}
6470	····[Test]
6471	····public void HasTypeCode()
6472	····{
6473	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6474	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6475	····}
6476	}
6477
6478
6479	[TestFixture]
6480	public class MappingTestCmpBi11OwnpabsNoTblAuto : NDOTest
6481	{
6482	····PersistenceManager pm;
6483	····NDOMapping mapping;
6484	····Class ownClass;
6485	····Class otherClass;
6486	····Class ownDerivedClass;
6487	····[SetUp]
6488	····public void Setup()
6489	····{
6490	········this.pm = PmFactory.NewPersistenceManager();
6491	········this.mapping = pm.NDOMapping;
6492	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsNoTblAutoLeftBase" );
6493	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsNoTblAutoRight" );
6494	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsNoTblAutoLeftDerived" );
6495	····}
6496	····[Test]
6497	····public void HasMappingTable()
6498	····{
6499	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
6500	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
6501	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
6502	····}
6503	····[Test]
6504	····public void HasTypeColumn()
6505	····{
6506	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
6507	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #10");
6508	····}
6509	····[Test]
6510	····public void HasTypeCode()
6511	····{
6512	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6513	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6514	····}
6515	}
6516
6517
6518	[TestFixture]
6519	public class MappingTestCmpBi11OwnpabsTblAuto : NDOTest
6520	{
6521	····PersistenceManager pm;
6522	····NDOMapping mapping;
6523	····Class ownClass;
6524	····Class otherClass;
6525	····Class ownDerivedClass;
6526	····[SetUp]
6527	····public void Setup()
6528	····{
6529	········this.pm = PmFactory.NewPersistenceManager();
6530	········this.mapping = pm.NDOMapping;
6531	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsTblAutoLeftBase" );
6532	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsTblAutoRight" );
6533	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsTblAutoLeftDerived" );
6534	····}
6535	····[Test]
6536	····public void HasMappingTable()
6537	····{
6538	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
6539	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
6540	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
6541	····}
6542	····[Test]
6543	····public void HasTypeColumn()
6544	····{
6545	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
6546	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
6547	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
6548	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
6549	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
6550	····}
6551	····[Test]
6552	····public void HasTypeCode()
6553	····{
6554	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6555	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6556	····}
6557	}
6558
6559
6560	[TestFixture]
6561	public class MappingTestCmpDirnOwnpabsNoTblAuto : NDOTest
6562	{
6563	····PersistenceManager pm;
6564	····NDOMapping mapping;
6565	····Class ownClass;
6566	····Class otherClass;
6567	····Class ownDerivedClass;
6568	····[SetUp]
6569	····public void Setup()
6570	····{
6571	········this.pm = PmFactory.NewPersistenceManager();
6572	········this.mapping = pm.NDOMapping;
6573	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsNoTblAutoLeftBase" );
6574	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsNoTblAutoRight" );
6575	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsNoTblAutoLeftDerived" );
6576	····}
6577	····[Test]
6578	····public void HasMappingTable()
6579	····{
6580	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
6581	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
6582	····}
6583	····[Test]
6584	····public void HasTypeColumn()
6585	····{
6586	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
6587	····}
6588	····[Test]
6589	····public void HasTypeCode()
6590	····{
6591	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6592	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6593	····}
6594	}
6595
6596
6597	[TestFixture]
6598	public class MappingTestCmpDirnOwnpabsTblAuto : NDOTest
6599	{
6600	····PersistenceManager pm;
6601	····NDOMapping mapping;
6602	····Class ownClass;
6603	····Class otherClass;
6604	····Class ownDerivedClass;
6605	····[SetUp]
6606	····public void Setup()
6607	····{
6608	········this.pm = PmFactory.NewPersistenceManager();
6609	········this.mapping = pm.NDOMapping;
6610	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsTblAutoLeftBase" );
6611	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsTblAutoRight" );
6612	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsTblAutoLeftDerived" );
6613	····}
6614	····[Test]
6615	····public void HasMappingTable()
6616	····{
6617	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
6618	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
6619	····}
6620	····[Test]
6621	····public void HasTypeColumn()
6622	····{
6623	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
6624	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
6625	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
6626	····}
6627	····[Test]
6628	····public void HasTypeCode()
6629	····{
6630	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6631	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6632	····}
6633	}
6634
6635
6636	[TestFixture]
6637	public class MappingTestCmpBin1OwnpabsNoTblAuto : NDOTest
6638	{
6639	····PersistenceManager pm;
6640	····NDOMapping mapping;
6641	····Class ownClass;
6642	····Class otherClass;
6643	····Class ownDerivedClass;
6644	····[SetUp]
6645	····public void Setup()
6646	····{
6647	········this.pm = PmFactory.NewPersistenceManager();
6648	········this.mapping = pm.NDOMapping;
6649	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsNoTblAutoLeftBase" );
6650	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsNoTblAutoRight" );
6651	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsNoTblAutoLeftDerived" );
6652	····}
6653	····[Test]
6654	····public void HasMappingTable()
6655	····{
6656	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
6657	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
6658	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
6659	····}
6660	····[Test]
6661	····public void HasTypeColumn()
6662	····{
6663	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
6664	····}
6665	····[Test]
6666	····public void HasTypeCode()
6667	····{
6668	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6669	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6670	····}
6671	}
6672
6673
6674	[TestFixture]
6675	public class MappingTestCmpBin1OwnpabsTblAuto : NDOTest
6676	{
6677	····PersistenceManager pm;
6678	····NDOMapping mapping;
6679	····Class ownClass;
6680	····Class otherClass;
6681	····Class ownDerivedClass;
6682	····[SetUp]
6683	····public void Setup()
6684	····{
6685	········this.pm = PmFactory.NewPersistenceManager();
6686	········this.mapping = pm.NDOMapping;
6687	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsTblAutoLeftBase" );
6688	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsTblAutoRight" );
6689	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsTblAutoLeftDerived" );
6690	····}
6691	····[Test]
6692	····public void HasMappingTable()
6693	····{
6694	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
6695	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
6696	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
6697	····}
6698	····[Test]
6699	····public void HasTypeColumn()
6700	····{
6701	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
6702	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
6703	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
6704	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
6705	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
6706	····}
6707	····[Test]
6708	····public void HasTypeCode()
6709	····{
6710	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6711	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6712	····}
6713	}
6714
6715
6716	[TestFixture]
6717	public class MappingTestCmpBi1nOwnpabsTblAuto : NDOTest
6718	{
6719	····PersistenceManager pm;
6720	····NDOMapping mapping;
6721	····Class ownClass;
6722	····Class otherClass;
6723	····Class ownDerivedClass;
6724	····[SetUp]
6725	····public void Setup()
6726	····{
6727	········this.pm = PmFactory.NewPersistenceManager();
6728	········this.mapping = pm.NDOMapping;
6729	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsTblAutoLeftBase" );
6730	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsTblAutoRight" );
6731	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsTblAutoLeftDerived" );
6732	····}
6733	····[Test]
6734	····public void HasMappingTable()
6735	····{
6736	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
6737	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
6738	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
6739	····}
6740	····[Test]
6741	····public void HasTypeColumn()
6742	····{
6743	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
6744	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
6745	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
6746	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
6747	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
6748	····}
6749	····[Test]
6750	····public void HasTypeCode()
6751	····{
6752	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6753	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6754	····}
6755	}
6756
6757
6758	[TestFixture]
6759	public class MappingTestCmpBinnOwnpabsTblAuto : NDOTest
6760	{
6761	····PersistenceManager pm;
6762	····NDOMapping mapping;
6763	····Class ownClass;
6764	····Class otherClass;
6765	····Class ownDerivedClass;
6766	····[SetUp]
6767	····public void Setup()
6768	····{
6769	········this.pm = PmFactory.NewPersistenceManager();
6770	········this.mapping = pm.NDOMapping;
6771	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsTblAutoLeftBase" );
6772	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsTblAutoRight" );
6773	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsTblAutoLeftDerived" );
6774	····}
6775	····[Test]
6776	····public void HasMappingTable()
6777	····{
6778	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
6779	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
6780	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
6781	····}
6782	····[Test]
6783	····public void HasTypeColumn()
6784	····{
6785	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
6786	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
6787	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
6788	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
6789	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
6790	····}
6791	····[Test]
6792	····public void HasTypeCode()
6793	····{
6794	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6795	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6796	····}
6797	}
6798
6799
6800	[TestFixture]
6801	public class MappingTestAgrDir1OthpabsNoTblAuto : NDOTest
6802	{
6803	····PersistenceManager pm;
6804	····NDOMapping mapping;
6805	····Class ownClass;
6806	····Class otherClass;
6807	····Class otherDerivedClass;
6808	····[SetUp]
6809	····public void Setup()
6810	····{
6811	········this.pm = PmFactory.NewPersistenceManager();
6812	········this.mapping = pm.NDOMapping;
6813	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsNoTblAutoLeft" );
6814	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsNoTblAutoRightBase" );
6815	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsNoTblAutoRightDerived" );
6816	····}
6817	····[Test]
6818	····public void HasMappingTable()
6819	····{
6820	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
6821	····}
6822	····[Test]
6823	····public void HasTypeColumn()
6824	····{
6825	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
6826	····}
6827	····[Test]
6828	····public void HasTypeCode()
6829	····{
6830	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
6831	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
6832	····}
6833	}
6834
6835
6836	[TestFixture]
6837	public class MappingTestAgrDir1OthpabsTblAuto : NDOTest
6838	{
6839	····PersistenceManager pm;
6840	····NDOMapping mapping;
6841	····Class ownClass;
6842	····Class otherClass;
6843	····Class otherDerivedClass;
6844	····[SetUp]
6845	····public void Setup()
6846	····{
6847	········this.pm = PmFactory.NewPersistenceManager();
6848	········this.mapping = pm.NDOMapping;
6849	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsTblAutoLeft" );
6850	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsTblAutoRightBase" );
6851	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsTblAutoRightDerived" );
6852	····}
6853	····[Test]
6854	····public void HasMappingTable()
6855	····{
6856	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
6857	····}
6858	····[Test]
6859	····public void HasTypeColumn()
6860	····{
6861	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
6862	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
6863	····}
6864	····[Test]
6865	····public void HasTypeCode()
6866	····{
6867	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
6868	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
6869	····}
6870	}
6871
6872
6873	[TestFixture]
6874	public class MappingTestAgrBi11OthpabsNoTblAuto : NDOTest
6875	{
6876	····PersistenceManager pm;
6877	····NDOMapping mapping;
6878	····Class ownClass;
6879	····Class otherClass;
6880	····Class otherDerivedClass;
6881	····[SetUp]
6882	····public void Setup()
6883	····{
6884	········this.pm = PmFactory.NewPersistenceManager();
6885	········this.mapping = pm.NDOMapping;
6886	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsNoTblAutoLeft" );
6887	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsNoTblAutoRightBase" );
6888	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsNoTblAutoRightDerived" );
6889	····}
6890	····[Test]
6891	····public void HasMappingTable()
6892	····{
6893	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
6894	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
6895	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
6896	····}
6897	····[Test]
6898	····public void HasTypeColumn()
6899	····{
6900	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
6901	····}
6902	····[Test]
6903	····public void HasTypeCode()
6904	····{
6905	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
6906	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
6907	····}
6908	}
6909
6910
6911	[TestFixture]
6912	public class MappingTestAgrBi11OthpabsTblAuto : NDOTest
6913	{
6914	····PersistenceManager pm;
6915	····NDOMapping mapping;
6916	····Class ownClass;
6917	····Class otherClass;
6918	····Class otherDerivedClass;
6919	····[SetUp]
6920	····public void Setup()
6921	····{
6922	········this.pm = PmFactory.NewPersistenceManager();
6923	········this.mapping = pm.NDOMapping;
6924	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsTblAutoLeft" );
6925	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsTblAutoRightBase" );
6926	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsTblAutoRightDerived" );
6927	····}
6928	····[Test]
6929	····public void HasMappingTable()
6930	····{
6931	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
6932	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
6933	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
6934	····}
6935	····[Test]
6936	····public void HasTypeColumn()
6937	····{
6938	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
6939	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
6940	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
6941	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
6942	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
6943	····}
6944	····[Test]
6945	····public void HasTypeCode()
6946	····{
6947	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
6948	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
6949	····}
6950	}
6951
6952
6953	[TestFixture]
6954	public class MappingTestAgrDirnOthpabsTblAuto : NDOTest
6955	{
6956	····PersistenceManager pm;
6957	····NDOMapping mapping;
6958	····Class ownClass;
6959	····Class otherClass;
6960	····Class otherDerivedClass;
6961	····[SetUp]
6962	····public void Setup()
6963	····{
6964	········this.pm = PmFactory.NewPersistenceManager();
6965	········this.mapping = pm.NDOMapping;
6966	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpabsTblAutoLeft" );
6967	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpabsTblAutoRightBase" );
6968	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpabsTblAutoRightDerived" );
6969	····}
6970	····[Test]
6971	····public void HasMappingTable()
6972	····{
6973	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
6974	····}
6975	····[Test]
6976	····public void HasTypeColumn()
6977	····{
6978	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
6979	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
6980	····}
6981	····[Test]
6982	····public void HasTypeCode()
6983	····{
6984	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
6985	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
6986	····}
6987	}
6988
6989
6990	[TestFixture]
6991	public class MappingTestAgrBin1OthpabsTblAuto : NDOTest
6992	{
6993	····PersistenceManager pm;
6994	····NDOMapping mapping;
6995	····Class ownClass;
6996	····Class otherClass;
6997	····Class otherDerivedClass;
6998	····[SetUp]
6999	····public void Setup()
7000	····{
7001	········this.pm = PmFactory.NewPersistenceManager();
7002	········this.mapping = pm.NDOMapping;
7003	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpabsTblAutoLeft" );
7004	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpabsTblAutoRightBase" );
7005	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpabsTblAutoRightDerived" );
7006	····}
7007	····[Test]
7008	····public void HasMappingTable()
7009	····{
7010	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7011	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
7012	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
7013	····}
7014	····[Test]
7015	····public void HasTypeColumn()
7016	····{
7017	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7018	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
7019	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
7020	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
7021	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
7022	····}
7023	····[Test]
7024	····public void HasTypeCode()
7025	····{
7026	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7027	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7028	····}
7029	}
7030
7031
7032	[TestFixture]
7033	public class MappingTestAgrBi1nOthpabsNoTblAuto : NDOTest
7034	{
7035	····PersistenceManager pm;
7036	····NDOMapping mapping;
7037	····Class ownClass;
7038	····Class otherClass;
7039	····Class otherDerivedClass;
7040	····[SetUp]
7041	····public void Setup()
7042	····{
7043	········this.pm = PmFactory.NewPersistenceManager();
7044	········this.mapping = pm.NDOMapping;
7045	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsNoTblAutoLeft" );
7046	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsNoTblAutoRightBase" );
7047	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsNoTblAutoRightDerived" );
7048	····}
7049	····[Test]
7050	····public void HasMappingTable()
7051	····{
7052	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
7053	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
7054	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
7055	····}
7056	····[Test]
7057	····public void HasTypeColumn()
7058	····{
7059	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
7060	····}
7061	····[Test]
7062	····public void HasTypeCode()
7063	····{
7064	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7065	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7066	····}
7067	}
7068
7069
7070	[TestFixture]
7071	public class MappingTestAgrBi1nOthpabsTblAuto : NDOTest
7072	{
7073	····PersistenceManager pm;
7074	····NDOMapping mapping;
7075	····Class ownClass;
7076	····Class otherClass;
7077	····Class otherDerivedClass;
7078	····[SetUp]
7079	····public void Setup()
7080	····{
7081	········this.pm = PmFactory.NewPersistenceManager();
7082	········this.mapping = pm.NDOMapping;
7083	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsTblAutoLeft" );
7084	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsTblAutoRightBase" );
7085	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsTblAutoRightDerived" );
7086	····}
7087	····[Test]
7088	····public void HasMappingTable()
7089	····{
7090	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7091	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
7092	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
7093	····}
7094	····[Test]
7095	····public void HasTypeColumn()
7096	····{
7097	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7098	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
7099	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
7100	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
7101	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
7102	····}
7103	····[Test]
7104	····public void HasTypeCode()
7105	····{
7106	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7107	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7108	····}
7109	}
7110
7111
7112	[TestFixture]
7113	public class MappingTestAgrBinnOthpabsTblAuto : NDOTest
7114	{
7115	····PersistenceManager pm;
7116	····NDOMapping mapping;
7117	····Class ownClass;
7118	····Class otherClass;
7119	····Class otherDerivedClass;
7120	····[SetUp]
7121	····public void Setup()
7122	····{
7123	········this.pm = PmFactory.NewPersistenceManager();
7124	········this.mapping = pm.NDOMapping;
7125	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpabsTblAutoLeft" );
7126	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpabsTblAutoRightBase" );
7127	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpabsTblAutoRightDerived" );
7128	····}
7129	····[Test]
7130	····public void HasMappingTable()
7131	····{
7132	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7133	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
7134	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
7135	····}
7136	····[Test]
7137	····public void HasTypeColumn()
7138	····{
7139	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7140	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
7141	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
7142	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
7143	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
7144	····}
7145	····[Test]
7146	····public void HasTypeCode()
7147	····{
7148	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7149	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7150	····}
7151	}
7152
7153
7154	[TestFixture]
7155	public class MappingTestCmpDir1OthpabsTblAuto : NDOTest
7156	{
7157	····PersistenceManager pm;
7158	····NDOMapping mapping;
7159	····Class ownClass;
7160	····Class otherClass;
7161	····Class otherDerivedClass;
7162	····[SetUp]
7163	····public void Setup()
7164	····{
7165	········this.pm = PmFactory.NewPersistenceManager();
7166	········this.mapping = pm.NDOMapping;
7167	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsTblAutoLeft" );
7168	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsTblAutoRightBase" );
7169	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsTblAutoRightDerived" );
7170	····}
7171	····[Test]
7172	····public void HasMappingTable()
7173	····{
7174	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7175	····}
7176	····[Test]
7177	····public void HasTypeColumn()
7178	····{
7179	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7180	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
7181	····}
7182	····[Test]
7183	····public void HasTypeCode()
7184	····{
7185	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7186	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7187	····}
7188	}
7189
7190
7191	[TestFixture]
7192	public class MappingTestCmpBi11OthpabsTblAuto : NDOTest
7193	{
7194	····PersistenceManager pm;
7195	····NDOMapping mapping;
7196	····Class ownClass;
7197	····Class otherClass;
7198	····Class otherDerivedClass;
7199	····[SetUp]
7200	····public void Setup()
7201	····{
7202	········this.pm = PmFactory.NewPersistenceManager();
7203	········this.mapping = pm.NDOMapping;
7204	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsTblAutoLeft" );
7205	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsTblAutoRightBase" );
7206	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsTblAutoRightDerived" );
7207	····}
7208	····[Test]
7209	····public void HasMappingTable()
7210	····{
7211	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7212	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
7213	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
7214	····}
7215	····[Test]
7216	····public void HasTypeColumn()
7217	····{
7218	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7219	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
7220	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
7221	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
7222	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
7223	····}
7224	····[Test]
7225	····public void HasTypeCode()
7226	····{
7227	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7228	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7229	····}
7230	}
7231
7232
7233	[TestFixture]
7234	public class MappingTestCmpDirnOthpabsTblAuto : NDOTest
7235	{
7236	····PersistenceManager pm;
7237	····NDOMapping mapping;
7238	····Class ownClass;
7239	····Class otherClass;
7240	····Class otherDerivedClass;
7241	····[SetUp]
7242	····public void Setup()
7243	····{
7244	········this.pm = PmFactory.NewPersistenceManager();
7245	········this.mapping = pm.NDOMapping;
7246	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpabsTblAutoLeft" );
7247	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpabsTblAutoRightBase" );
7248	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpabsTblAutoRightDerived" );
7249	····}
7250	····[Test]
7251	····public void HasMappingTable()
7252	····{
7253	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7254	····}
7255	····[Test]
7256	····public void HasTypeColumn()
7257	····{
7258	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7259	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
7260	····}
7261	····[Test]
7262	····public void HasTypeCode()
7263	····{
7264	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7265	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7266	····}
7267	}
7268
7269
7270	[TestFixture]
7271	public class MappingTestCmpBin1OthpabsTblAuto : NDOTest
7272	{
7273	····PersistenceManager pm;
7274	····NDOMapping mapping;
7275	····Class ownClass;
7276	····Class otherClass;
7277	····Class otherDerivedClass;
7278	····[SetUp]
7279	····public void Setup()
7280	····{
7281	········this.pm = PmFactory.NewPersistenceManager();
7282	········this.mapping = pm.NDOMapping;
7283	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpabsTblAutoLeft" );
7284	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpabsTblAutoRightBase" );
7285	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpabsTblAutoRightDerived" );
7286	····}
7287	····[Test]
7288	····public void HasMappingTable()
7289	····{
7290	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7291	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
7292	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
7293	····}
7294	····[Test]
7295	····public void HasTypeColumn()
7296	····{
7297	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7298	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
7299	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
7300	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
7301	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
7302	····}
7303	····[Test]
7304	····public void HasTypeCode()
7305	····{
7306	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7307	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7308	····}
7309	}
7310
7311
7312	[TestFixture]
7313	public class MappingTestCmpBi1nOthpabsTblAuto : NDOTest
7314	{
7315	····PersistenceManager pm;
7316	····NDOMapping mapping;
7317	····Class ownClass;
7318	····Class otherClass;
7319	····Class otherDerivedClass;
7320	····[SetUp]
7321	····public void Setup()
7322	····{
7323	········this.pm = PmFactory.NewPersistenceManager();
7324	········this.mapping = pm.NDOMapping;
7325	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsTblAutoLeft" );
7326	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsTblAutoRightBase" );
7327	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsTblAutoRightDerived" );
7328	····}
7329	····[Test]
7330	····public void HasMappingTable()
7331	····{
7332	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7333	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
7334	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
7335	····}
7336	····[Test]
7337	····public void HasTypeColumn()
7338	····{
7339	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7340	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
7341	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
7342	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
7343	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
7344	····}
7345	····[Test]
7346	····public void HasTypeCode()
7347	····{
7348	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7349	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7350	····}
7351	}
7352
7353
7354	[TestFixture]
7355	public class MappingTestCmpBinnOthpabsTblAuto : NDOTest
7356	{
7357	····PersistenceManager pm;
7358	····NDOMapping mapping;
7359	····Class ownClass;
7360	····Class otherClass;
7361	····Class otherDerivedClass;
7362	····[SetUp]
7363	····public void Setup()
7364	····{
7365	········this.pm = PmFactory.NewPersistenceManager();
7366	········this.mapping = pm.NDOMapping;
7367	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpabsTblAutoLeft" );
7368	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpabsTblAutoRightBase" );
7369	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpabsTblAutoRightDerived" );
7370	····}
7371	····[Test]
7372	····public void HasMappingTable()
7373	····{
7374	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7375	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
7376	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
7377	····}
7378	····[Test]
7379	····public void HasTypeColumn()
7380	····{
7381	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7382	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
7383	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
7384	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
7385	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
7386	····}
7387	····[Test]
7388	····public void HasTypeCode()
7389	····{
7390	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7391	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7392	····}
7393	}
7394
7395
7396	[TestFixture]
7397	public class MappingTestAgrDir1OwnpabsOthpabsNoTblAuto : NDOTest
7398	{
7399	····PersistenceManager pm;
7400	····NDOMapping mapping;
7401	····Class ownClass;
7402	····Class otherClass;
7403	····Class ownDerivedClass;
7404	····Class otherDerivedClass;
7405	····[SetUp]
7406	····public void Setup()
7407	····{
7408	········this.pm = PmFactory.NewPersistenceManager();
7409	········this.mapping = pm.NDOMapping;
7410	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsNoTblAutoLeftBase" );
7411	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsNoTblAutoRightBase" );
7412	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsNoTblAutoLeftDerived" );
7413	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsNoTblAutoRightDerived" );
7414	····}
7415	····[Test]
7416	····public void HasMappingTable()
7417	····{
7418	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
7419	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
7420	····}
7421	····[Test]
7422	····public void HasTypeColumn()
7423	····{
7424	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
7425	····}
7426	····[Test]
7427	····public void HasTypeCode()
7428	····{
7429	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7430	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7431	····}
7432	}
7433
7434
7435	[TestFixture]
7436	public class MappingTestAgrDir1OwnpabsOthpabsTblAuto : NDOTest
7437	{
7438	····PersistenceManager pm;
7439	····NDOMapping mapping;
7440	····Class ownClass;
7441	····Class otherClass;
7442	····Class ownDerivedClass;
7443	····Class otherDerivedClass;
7444	····[SetUp]
7445	····public void Setup()
7446	····{
7447	········this.pm = PmFactory.NewPersistenceManager();
7448	········this.mapping = pm.NDOMapping;
7449	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsTblAutoLeftBase" );
7450	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsTblAutoRightBase" );
7451	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsTblAutoLeftDerived" );
7452	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsTblAutoRightDerived" );
7453	····}
7454	····[Test]
7455	····public void HasMappingTable()
7456	····{
7457	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7458	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
7459	····}
7460	····[Test]
7461	····public void HasTypeColumn()
7462	····{
7463	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
7464	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
7465	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7466	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
7467	····}
7468	····[Test]
7469	····public void HasTypeCode()
7470	····{
7471	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7472	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7473	····}
7474	}
7475
7476
7477	[TestFixture]
7478	public class MappingTestAgrBi11OwnpabsOthpabsNoTblAuto : NDOTest
7479	{
7480	····PersistenceManager pm;
7481	····NDOMapping mapping;
7482	····Class ownClass;
7483	····Class otherClass;
7484	····Class ownDerivedClass;
7485	····Class otherDerivedClass;
7486	····[SetUp]
7487	····public void Setup()
7488	····{
7489	········this.pm = PmFactory.NewPersistenceManager();
7490	········this.mapping = pm.NDOMapping;
7491	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsNoTblAutoLeftBase" );
7492	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsNoTblAutoRightBase" );
7493	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsNoTblAutoLeftDerived" );
7494	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsNoTblAutoRightDerived" );
7495	····}
7496	····[Test]
7497	····public void HasMappingTable()
7498	····{
7499	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
7500	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
7501	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
7502	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
7503	····}
7504	····[Test]
7505	····public void HasTypeColumn()
7506	····{
7507	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
7508	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #10");
7509	····}
7510	····[Test]
7511	····public void HasTypeCode()
7512	····{
7513	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7514	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7515	····}
7516	}
7517
7518
7519	[TestFixture]
7520	public class MappingTestAgrBi11OwnpabsOthpabsTblAuto : NDOTest
7521	{
7522	····PersistenceManager pm;
7523	····NDOMapping mapping;
7524	····Class ownClass;
7525	····Class otherClass;
7526	····Class ownDerivedClass;
7527	····Class otherDerivedClass;
7528	····[SetUp]
7529	····public void Setup()
7530	····{
7531	········this.pm = PmFactory.NewPersistenceManager();
7532	········this.mapping = pm.NDOMapping;
7533	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsTblAutoLeftBase" );
7534	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsTblAutoRightBase" );
7535	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsTblAutoLeftDerived" );
7536	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsTblAutoRightDerived" );
7537	····}
7538	····[Test]
7539	····public void HasMappingTable()
7540	····{
7541	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7542	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
7543	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
7544	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
7545	····}
7546	····[Test]
7547	····public void HasTypeColumn()
7548	····{
7549	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
7550	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
7551	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7552	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
7553	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
7554	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
7555	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
7556	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
7557	····}
7558	····[Test]
7559	····public void HasTypeCode()
7560	····{
7561	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7562	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7563	····}
7564	}
7565
7566
7567	[TestFixture]
7568	public class MappingTestAgrDirnOwnpabsOthpabsTblAuto : NDOTest
7569	{
7570	····PersistenceManager pm;
7571	····NDOMapping mapping;
7572	····Class ownClass;
7573	····Class otherClass;
7574	····Class ownDerivedClass;
7575	····Class otherDerivedClass;
7576	····[SetUp]
7577	····public void Setup()
7578	····{
7579	········this.pm = PmFactory.NewPersistenceManager();
7580	········this.mapping = pm.NDOMapping;
7581	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsOthpabsTblAutoLeftBase" );
7582	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsOthpabsTblAutoRightBase" );
7583	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsOthpabsTblAutoLeftDerived" );
7584	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsOthpabsTblAutoRightDerived" );
7585	····}
7586	····[Test]
7587	····public void HasMappingTable()
7588	····{
7589	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7590	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
7591	····}
7592	····[Test]
7593	····public void HasTypeColumn()
7594	····{
7595	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
7596	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
7597	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7598	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
7599	····}
7600	····[Test]
7601	····public void HasTypeCode()
7602	····{
7603	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7604	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7605	····}
7606	}
7607
7608
7609	[TestFixture]
7610	public class MappingTestAgrBin1OwnpabsOthpabsTblAuto : NDOTest
7611	{
7612	····PersistenceManager pm;
7613	····NDOMapping mapping;
7614	····Class ownClass;
7615	····Class otherClass;
7616	····Class ownDerivedClass;
7617	····Class otherDerivedClass;
7618	····[SetUp]
7619	····public void Setup()
7620	····{
7621	········this.pm = PmFactory.NewPersistenceManager();
7622	········this.mapping = pm.NDOMapping;
7623	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsOthpabsTblAutoLeftBase" );
7624	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsOthpabsTblAutoRightBase" );
7625	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsOthpabsTblAutoLeftDerived" );
7626	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsOthpabsTblAutoRightDerived" );
7627	····}
7628	····[Test]
7629	····public void HasMappingTable()
7630	····{
7631	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7632	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
7633	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
7634	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
7635	····}
7636	····[Test]
7637	····public void HasTypeColumn()
7638	····{
7639	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
7640	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
7641	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7642	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
7643	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
7644	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
7645	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
7646	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
7647	····}
7648	····[Test]
7649	····public void HasTypeCode()
7650	····{
7651	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7652	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7653	····}
7654	}
7655
7656
7657	[TestFixture]
7658	public class MappingTestAgrBi1nOwnpabsOthpabsTblAuto : NDOTest
7659	{
7660	····PersistenceManager pm;
7661	····NDOMapping mapping;
7662	····Class ownClass;
7663	····Class otherClass;
7664	····Class ownDerivedClass;
7665	····Class otherDerivedClass;
7666	····[SetUp]
7667	····public void Setup()
7668	····{
7669	········this.pm = PmFactory.NewPersistenceManager();
7670	········this.mapping = pm.NDOMapping;
7671	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsOthpabsTblAutoLeftBase" );
7672	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsOthpabsTblAutoRightBase" );
7673	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsOthpabsTblAutoLeftDerived" );
7674	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsOthpabsTblAutoRightDerived" );
7675	····}
7676	····[Test]
7677	····public void HasMappingTable()
7678	····{
7679	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7680	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
7681	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
7682	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
7683	····}
7684	····[Test]
7685	····public void HasTypeColumn()
7686	····{
7687	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
7688	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
7689	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7690	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
7691	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
7692	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
7693	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
7694	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
7695	····}
7696	····[Test]
7697	····public void HasTypeCode()
7698	····{
7699	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7700	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7701	····}
7702	}
7703
7704
7705	[TestFixture]
7706	public class MappingTestAgrBinnOwnpabsOthpabsTblAuto : NDOTest
7707	{
7708	····PersistenceManager pm;
7709	····NDOMapping mapping;
7710	····Class ownClass;
7711	····Class otherClass;
7712	····Class ownDerivedClass;
7713	····Class otherDerivedClass;
7714	····[SetUp]
7715	····public void Setup()
7716	····{
7717	········this.pm = PmFactory.NewPersistenceManager();
7718	········this.mapping = pm.NDOMapping;
7719	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsOthpabsTblAutoLeftBase" );
7720	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsOthpabsTblAutoRightBase" );
7721	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsOthpabsTblAutoLeftDerived" );
7722	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsOthpabsTblAutoRightDerived" );
7723	····}
7724	····[Test]
7725	····public void HasMappingTable()
7726	····{
7727	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7728	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
7729	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
7730	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
7731	····}
7732	····[Test]
7733	····public void HasTypeColumn()
7734	····{
7735	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
7736	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
7737	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7738	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
7739	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
7740	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
7741	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
7742	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
7743	····}
7744	····[Test]
7745	····public void HasTypeCode()
7746	····{
7747	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7748	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7749	····}
7750	}
7751
7752
7753	[TestFixture]
7754	public class MappingTestCmpDir1OwnpabsOthpabsTblAuto : NDOTest
7755	{
7756	····PersistenceManager pm;
7757	····NDOMapping mapping;
7758	····Class ownClass;
7759	····Class otherClass;
7760	····Class ownDerivedClass;
7761	····Class otherDerivedClass;
7762	····[SetUp]
7763	····public void Setup()
7764	····{
7765	········this.pm = PmFactory.NewPersistenceManager();
7766	········this.mapping = pm.NDOMapping;
7767	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsTblAutoLeftBase" );
7768	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsTblAutoRightBase" );
7769	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsTblAutoLeftDerived" );
7770	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsTblAutoRightDerived" );
7771	····}
7772	····[Test]
7773	····public void HasMappingTable()
7774	····{
7775	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7776	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
7777	····}
7778	····[Test]
7779	····public void HasTypeColumn()
7780	····{
7781	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
7782	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
7783	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7784	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
7785	····}
7786	····[Test]
7787	····public void HasTypeCode()
7788	····{
7789	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7790	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7791	····}
7792	}
7793
7794
7795	[TestFixture]
7796	public class MappingTestCmpBi11OwnpabsOthpabsTblAuto : NDOTest
7797	{
7798	····PersistenceManager pm;
7799	····NDOMapping mapping;
7800	····Class ownClass;
7801	····Class otherClass;
7802	····Class ownDerivedClass;
7803	····Class otherDerivedClass;
7804	····[SetUp]
7805	····public void Setup()
7806	····{
7807	········this.pm = PmFactory.NewPersistenceManager();
7808	········this.mapping = pm.NDOMapping;
7809	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsTblAutoLeftBase" );
7810	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsTblAutoRightBase" );
7811	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsTblAutoLeftDerived" );
7812	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsTblAutoRightDerived" );
7813	····}
7814	····[Test]
7815	····public void HasMappingTable()
7816	····{
7817	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7818	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
7819	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
7820	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
7821	····}
7822	····[Test]
7823	····public void HasTypeColumn()
7824	····{
7825	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
7826	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
7827	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7828	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
7829	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
7830	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
7831	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
7832	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
7833	····}
7834	····[Test]
7835	····public void HasTypeCode()
7836	····{
7837	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7838	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7839	····}
7840	}
7841
7842
7843	[TestFixture]
7844	public class MappingTestCmpDirnOwnpabsOthpabsTblAuto : NDOTest
7845	{
7846	····PersistenceManager pm;
7847	····NDOMapping mapping;
7848	····Class ownClass;
7849	····Class otherClass;
7850	····Class ownDerivedClass;
7851	····Class otherDerivedClass;
7852	····[SetUp]
7853	····public void Setup()
7854	····{
7855	········this.pm = PmFactory.NewPersistenceManager();
7856	········this.mapping = pm.NDOMapping;
7857	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsOthpabsTblAutoLeftBase" );
7858	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsOthpabsTblAutoRightBase" );
7859	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsOthpabsTblAutoLeftDerived" );
7860	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsOthpabsTblAutoRightDerived" );
7861	····}
7862	····[Test]
7863	····public void HasMappingTable()
7864	····{
7865	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7866	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
7867	····}
7868	····[Test]
7869	····public void HasTypeColumn()
7870	····{
7871	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
7872	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
7873	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7874	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
7875	····}
7876	····[Test]
7877	····public void HasTypeCode()
7878	····{
7879	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7880	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7881	····}
7882	}
7883
7884
7885	[TestFixture]
7886	public class MappingTestCmpBin1OwnpabsOthpabsTblAuto : NDOTest
7887	{
7888	····PersistenceManager pm;
7889	····NDOMapping mapping;
7890	····Class ownClass;
7891	····Class otherClass;
7892	····Class ownDerivedClass;
7893	····Class otherDerivedClass;
7894	····[SetUp]
7895	····public void Setup()
7896	····{
7897	········this.pm = PmFactory.NewPersistenceManager();
7898	········this.mapping = pm.NDOMapping;
7899	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsOthpabsTblAutoLeftBase" );
7900	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsOthpabsTblAutoRightBase" );
7901	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsOthpabsTblAutoLeftDerived" );
7902	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsOthpabsTblAutoRightDerived" );
7903	····}
7904	····[Test]
7905	····public void HasMappingTable()
7906	····{
7907	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7908	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
7909	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
7910	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
7911	····}
7912	····[Test]
7913	····public void HasTypeColumn()
7914	····{
7915	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
7916	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
7917	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7918	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
7919	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
7920	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
7921	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
7922	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
7923	····}
7924	····[Test]
7925	····public void HasTypeCode()
7926	····{
7927	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7928	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7929	····}
7930	}
7931
7932
7933	[TestFixture]
7934	public class MappingTestCmpBi1nOwnpabsOthpabsTblAuto : NDOTest
7935	{
7936	····PersistenceManager pm;
7937	····NDOMapping mapping;
7938	····Class ownClass;
7939	····Class otherClass;
7940	····Class ownDerivedClass;
7941	····Class otherDerivedClass;
7942	····[SetUp]
7943	····public void Setup()
7944	····{
7945	········this.pm = PmFactory.NewPersistenceManager();
7946	········this.mapping = pm.NDOMapping;
7947	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsOthpabsTblAutoLeftBase" );
7948	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsOthpabsTblAutoRightBase" );
7949	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsOthpabsTblAutoLeftDerived" );
7950	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsOthpabsTblAutoRightDerived" );
7951	····}
7952	····[Test]
7953	····public void HasMappingTable()
7954	····{
7955	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7956	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
7957	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
7958	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
7959	····}
7960	····[Test]
7961	····public void HasTypeColumn()
7962	····{
7963	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
7964	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
7965	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7966	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
7967	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
7968	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
7969	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
7970	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
7971	····}
7972	····[Test]
7973	····public void HasTypeCode()
7974	····{
7975	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7976	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7977	····}
7978	}
7979
7980
7981	[TestFixture]
7982	public class MappingTestCmpBinnOwnpabsOthpabsTblAuto : NDOTest
7983	{
7984	····PersistenceManager pm;
7985	····NDOMapping mapping;
7986	····Class ownClass;
7987	····Class otherClass;
7988	····Class ownDerivedClass;
7989	····Class otherDerivedClass;
7990	····[SetUp]
7991	····public void Setup()
7992	····{
7993	········this.pm = PmFactory.NewPersistenceManager();
7994	········this.mapping = pm.NDOMapping;
7995	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsOthpabsTblAutoLeftBase" );
7996	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsOthpabsTblAutoRightBase" );
7997	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsOthpabsTblAutoLeftDerived" );
7998	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsOthpabsTblAutoRightDerived" );
7999	····}
8000	····[Test]
8001	····public void HasMappingTable()
8002	····{
8003	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
8004	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
8005	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
8006	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
8007	····}
8008	····[Test]
8009	····public void HasTypeColumn()
8010	····{
8011	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
8012	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
8013	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
8014	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
8015	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
8016	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
8017	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
8018	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
8019	····}
8020	····[Test]
8021	····public void HasTypeCode()
8022	····{
8023	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8024	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
8025	····}
8026	}
8027
8028
8029	[TestFixture]
8030	public class MappingTestAgrDir1OwnpabsNoTblGuid : NDOTest
8031	{
8032	····PersistenceManager pm;
8033	····NDOMapping mapping;
8034	····Class ownClass;
8035	····Class otherClass;
8036	····Class ownDerivedClass;
8037	····[SetUp]
8038	····public void Setup()
8039	····{
8040	········this.pm = PmFactory.NewPersistenceManager();
8041	········this.mapping = pm.NDOMapping;
8042	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsNoTblGuidLeftBase" );
8043	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsNoTblGuidRight" );
8044	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsNoTblGuidLeftDerived" );
8045	····}
8046	····[Test]
8047	····public void HasMappingTable()
8048	····{
8049	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
8050	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
8051	····}
8052	····[Test]
8053	····public void HasTypeColumn()
8054	····{
8055	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
8056	····}
8057	····[Test]
8058	····public void HasTypeCode()
8059	····{
8060	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8061	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8062	····}
8063	}
8064
8065
8066	[TestFixture]
8067	public class MappingTestAgrDir1OwnpabsTblGuid : NDOTest
8068	{
8069	····PersistenceManager pm;
8070	····NDOMapping mapping;
8071	····Class ownClass;
8072	····Class otherClass;
8073	····Class ownDerivedClass;
8074	····[SetUp]
8075	····public void Setup()
8076	····{
8077	········this.pm = PmFactory.NewPersistenceManager();
8078	········this.mapping = pm.NDOMapping;
8079	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsTblGuidLeftBase" );
8080	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsTblGuidRight" );
8081	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsTblGuidLeftDerived" );
8082	····}
8083	····[Test]
8084	····public void HasMappingTable()
8085	····{
8086	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
8087	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
8088	····}
8089	····[Test]
8090	····public void HasTypeColumn()
8091	····{
8092	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
8093	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
8094	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
8095	····}
8096	····[Test]
8097	····public void HasTypeCode()
8098	····{
8099	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8100	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8101	····}
8102	}
8103
8104
8105	[TestFixture]
8106	public class MappingTestAgrBi11OwnpabsNoTblGuid : NDOTest
8107	{
8108	····PersistenceManager pm;
8109	····NDOMapping mapping;
8110	····Class ownClass;
8111	····Class otherClass;
8112	····Class ownDerivedClass;
8113	····[SetUp]
8114	····public void Setup()
8115	····{
8116	········this.pm = PmFactory.NewPersistenceManager();
8117	········this.mapping = pm.NDOMapping;
8118	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsNoTblGuidLeftBase" );
8119	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsNoTblGuidRight" );
8120	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsNoTblGuidLeftDerived" );
8121	····}
8122	····[Test]
8123	····public void HasMappingTable()
8124	····{
8125	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
8126	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
8127	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
8128	····}
8129	····[Test]
8130	····public void HasTypeColumn()
8131	····{
8132	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
8133	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #10");
8134	····}
8135	····[Test]
8136	····public void HasTypeCode()
8137	····{
8138	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8139	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8140	····}
8141	}
8142
8143
8144	[TestFixture]
8145	public class MappingTestAgrBi11OwnpabsTblGuid : NDOTest
8146	{
8147	····PersistenceManager pm;
8148	····NDOMapping mapping;
8149	····Class ownClass;
8150	····Class otherClass;
8151	····Class ownDerivedClass;
8152	····[SetUp]
8153	····public void Setup()
8154	····{
8155	········this.pm = PmFactory.NewPersistenceManager();
8156	········this.mapping = pm.NDOMapping;
8157	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsTblGuidLeftBase" );
8158	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsTblGuidRight" );
8159	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsTblGuidLeftDerived" );
8160	····}
8161	····[Test]
8162	····public void HasMappingTable()
8163	····{
8164	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
8165	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
8166	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
8167	····}
8168	····[Test]
8169	····public void HasTypeColumn()
8170	····{
8171	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
8172	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
8173	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
8174	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
8175	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
8176	····}
8177	····[Test]
8178	····public void HasTypeCode()
8179	····{
8180	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8181	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8182	····}
8183	}
8184
8185
8186	[TestFixture]
8187	public class MappingTestAgrDirnOwnpabsNoTblGuid : NDOTest
8188	{
8189	····PersistenceManager pm;
8190	····NDOMapping mapping;
8191	····Class ownClass;
8192	····Class otherClass;
8193	····Class ownDerivedClass;
8194	····[SetUp]
8195	····public void Setup()
8196	····{
8197	········this.pm = PmFactory.NewPersistenceManager();
8198	········this.mapping = pm.NDOMapping;
8199	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsNoTblGuidLeftBase" );
8200	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsNoTblGuidRight" );
8201	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsNoTblGuidLeftDerived" );
8202	····}
8203	····[Test]
8204	····public void HasMappingTable()
8205	····{
8206	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
8207	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
8208	····}
8209	····[Test]
8210	····public void HasTypeColumn()
8211	····{
8212	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
8213	····}
8214	····[Test]
8215	····public void HasTypeCode()
8216	····{
8217	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8218	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8219	····}
8220	}
8221
8222
8223	[TestFixture]
8224	public class MappingTestAgrDirnOwnpabsTblGuid : NDOTest
8225	{
8226	····PersistenceManager pm;
8227	····NDOMapping mapping;
8228	····Class ownClass;
8229	····Class otherClass;
8230	····Class ownDerivedClass;
8231	····[SetUp]
8232	····public void Setup()
8233	····{
8234	········this.pm = PmFactory.NewPersistenceManager();
8235	········this.mapping = pm.NDOMapping;
8236	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsTblGuidLeftBase" );
8237	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsTblGuidRight" );
8238	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsTblGuidLeftDerived" );
8239	····}
8240	····[Test]
8241	····public void HasMappingTable()
8242	····{
8243	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
8244	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
8245	····}
8246	····[Test]
8247	····public void HasTypeColumn()
8248	····{
8249	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
8250	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
8251	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
8252	····}
8253	····[Test]
8254	····public void HasTypeCode()
8255	····{
8256	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8257	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8258	····}
8259	}
8260
8261
8262	[TestFixture]
8263	public class MappingTestAgrBin1OwnpabsNoTblGuid : NDOTest
8264	{
8265	····PersistenceManager pm;
8266	····NDOMapping mapping;
8267	····Class ownClass;
8268	····Class otherClass;
8269	····Class ownDerivedClass;
8270	····[SetUp]
8271	····public void Setup()
8272	····{
8273	········this.pm = PmFactory.NewPersistenceManager();
8274	········this.mapping = pm.NDOMapping;
8275	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsNoTblGuidLeftBase" );
8276	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsNoTblGuidRight" );
8277	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsNoTblGuidLeftDerived" );
8278	····}
8279	····[Test]
8280	····public void HasMappingTable()
8281	····{
8282	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
8283	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
8284	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
8285	····}
8286	····[Test]
8287	····public void HasTypeColumn()
8288	····{
8289	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
8290	····}
8291	····[Test]
8292	····public void HasTypeCode()
8293	····{
8294	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8295	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8296	····}
8297	}
8298
8299
8300	[TestFixture]
8301	public class MappingTestAgrBin1OwnpabsTblGuid : NDOTest
8302	{
8303	····PersistenceManager pm;
8304	····NDOMapping mapping;
8305	····Class ownClass;
8306	····Class otherClass;
8307	····Class ownDerivedClass;
8308	····[SetUp]
8309	····public void Setup()
8310	····{
8311	········this.pm = PmFactory.NewPersistenceManager();
8312	········this.mapping = pm.NDOMapping;
8313	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsTblGuidLeftBase" );
8314	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsTblGuidRight" );
8315	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsTblGuidLeftDerived" );
8316	····}
8317	····[Test]
8318	····public void HasMappingTable()
8319	····{
8320	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
8321	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
8322	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
8323	····}
8324	····[Test]
8325	····public void HasTypeColumn()
8326	····{
8327	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
8328	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
8329	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
8330	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
8331	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
8332	····}
8333	····[Test]
8334	····public void HasTypeCode()
8335	····{
8336	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8337	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8338	····}
8339	}
8340
8341
8342	[TestFixture]
8343	public class MappingTestAgrBi1nOwnpabsTblGuid : NDOTest
8344	{
8345	····PersistenceManager pm;
8346	····NDOMapping mapping;
8347	····Class ownClass;
8348	····Class otherClass;
8349	····Class ownDerivedClass;
8350	····[SetUp]
8351	····public void Setup()
8352	····{
8353	········this.pm = PmFactory.NewPersistenceManager();
8354	········this.mapping = pm.NDOMapping;
8355	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsTblGuidLeftBase" );
8356	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsTblGuidRight" );
8357	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsTblGuidLeftDerived" );
8358	····}
8359	····[Test]
8360	····public void HasMappingTable()
8361	····{
8362	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
8363	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
8364	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
8365	····}
8366	····[Test]
8367	····public void HasTypeColumn()
8368	····{
8369	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
8370	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
8371	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
8372	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
8373	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
8374	····}
8375	····[Test]
8376	····public void HasTypeCode()
8377	····{
8378	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8379	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8380	····}
8381	}
8382
8383
8384	[TestFixture]
8385	public class MappingTestAgrBinnOwnpabsTblGuid : NDOTest
8386	{
8387	····PersistenceManager pm;
8388	····NDOMapping mapping;
8389	····Class ownClass;
8390	····Class otherClass;
8391	····Class ownDerivedClass;
8392	····[SetUp]
8393	····public void Setup()
8394	····{
8395	········this.pm = PmFactory.NewPersistenceManager();
8396	········this.mapping = pm.NDOMapping;
8397	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsTblGuidLeftBase" );
8398	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsTblGuidRight" );
8399	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsTblGuidLeftDerived" );
8400	····}
8401	····[Test]
8402	····public void HasMappingTable()
8403	····{
8404	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
8405	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
8406	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
8407	····}
8408	····[Test]
8409	····public void HasTypeColumn()
8410	····{
8411	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
8412	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
8413	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
8414	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
8415	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
8416	····}
8417	····[Test]
8418	····public void HasTypeCode()
8419	····{
8420	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8421	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8422	····}
8423	}
8424
8425
8426	[TestFixture]
8427	public class MappingTestCmpDir1OwnpabsNoTblGuid : NDOTest
8428	{
8429	····PersistenceManager pm;
8430	····NDOMapping mapping;
8431	····Class ownClass;
8432	····Class otherClass;
8433	····Class ownDerivedClass;
8434	····[SetUp]
8435	····public void Setup()
8436	····{
8437	········this.pm = PmFactory.NewPersistenceManager();
8438	········this.mapping = pm.NDOMapping;
8439	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsNoTblGuidLeftBase" );
8440	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsNoTblGuidRight" );
8441	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsNoTblGuidLeftDerived" );
8442	····}
8443	····[Test]
8444	····public void HasMappingTable()
8445	····{
8446	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
8447	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
8448	····}
8449	····[Test]
8450	····public void HasTypeColumn()
8451	····{
8452	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
8453	····}
8454	····[Test]
8455	····public void HasTypeCode()
8456	····{
8457	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8458	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8459	····}
8460	}
8461
8462
8463	[TestFixture]
8464	public class MappingTestCmpDir1OwnpabsTblGuid : NDOTest
8465	{
8466	····PersistenceManager pm;
8467	····NDOMapping mapping;
8468	····Class ownClass;
8469	····Class otherClass;
8470	····Class ownDerivedClass;
8471	····[SetUp]
8472	····public void Setup()
8473	····{
8474	········this.pm = PmFactory.NewPersistenceManager();
8475	········this.mapping = pm.NDOMapping;
8476	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsTblGuidLeftBase" );
8477	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsTblGuidRight" );
8478	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsTblGuidLeftDerived" );
8479	····}
8480	····[Test]
8481	····public void HasMappingTable()
8482	····{
8483	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
8484	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
8485	····}
8486	····[Test]
8487	····public void HasTypeColumn()
8488	····{
8489	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
8490	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
8491	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
8492	····}
8493	····[Test]
8494	····public void HasTypeCode()
8495	····{
8496	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8497	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8498	····}
8499	}
8500
8501
8502	[TestFixture]
8503	public class MappingTestCmpBi11OwnpabsNoTblGuid : NDOTest
8504	{
8505	····PersistenceManager pm;
8506	····NDOMapping mapping;
8507	····Class ownClass;
8508	····Class otherClass;
8509	····Class ownDerivedClass;
8510	····[SetUp]
8511	····public void Setup()
8512	····{
8513	········this.pm = PmFactory.NewPersistenceManager();
8514	········this.mapping = pm.NDOMapping;
8515	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsNoTblGuidLeftBase" );
8516	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsNoTblGuidRight" );
8517	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsNoTblGuidLeftDerived" );
8518	····}
8519	····[Test]
8520	····public void HasMappingTable()
8521	····{
8522	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
8523	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
8524	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
8525	····}
8526	····[Test]
8527	····public void HasTypeColumn()
8528	····{
8529	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
8530	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #10");
8531	····}
8532	····[Test]
8533	····public void HasTypeCode()
8534	····{
8535	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8536	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8537	····}
8538	}
8539
8540
8541	[TestFixture]
8542	public class MappingTestCmpBi11OwnpabsTblGuid : NDOTest
8543	{
8544	····PersistenceManager pm;
8545	····NDOMapping mapping;
8546	····Class ownClass;
8547	····Class otherClass;
8548	····Class ownDerivedClass;
8549	····[SetUp]
8550	····public void Setup()
8551	····{
8552	········this.pm = PmFactory.NewPersistenceManager();
8553	········this.mapping = pm.NDOMapping;
8554	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsTblGuidLeftBase" );
8555	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsTblGuidRight" );
8556	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsTblGuidLeftDerived" );
8557	····}
8558	····[Test]
8559	····public void HasMappingTable()
8560	····{
8561	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
8562	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
8563	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
8564	····}
8565	····[Test]
8566	····public void HasTypeColumn()
8567	····{
8568	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
8569	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
8570	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
8571	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
8572	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
8573	····}
8574	····[Test]
8575	····public void HasTypeCode()
8576	····{
8577	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8578	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8579	····}
8580	}
8581
8582
8583	[TestFixture]
8584	public class MappingTestCmpDirnOwnpabsNoTblGuid : NDOTest
8585	{
8586	····PersistenceManager pm;
8587	····NDOMapping mapping;
8588	····Class ownClass;
8589	····Class otherClass;
8590	····Class ownDerivedClass;
8591	····[SetUp]
8592	····public void Setup()
8593	····{
8594	········this.pm = PmFactory.NewPersistenceManager();
8595	········this.mapping = pm.NDOMapping;
8596	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsNoTblGuidLeftBase" );
8597	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsNoTblGuidRight" );
8598	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsNoTblGuidLeftDerived" );
8599	····}
8600	····[Test]
8601	····public void HasMappingTable()
8602	····{
8603	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
8604	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
8605	····}
8606	····[Test]
8607	····public void HasTypeColumn()
8608	····{
8609	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
8610	····}
8611	····[Test]
8612	····public void HasTypeCode()
8613	····{
8614	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8615	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8616	····}
8617	}
8618
8619
8620	[TestFixture]
8621	public class MappingTestCmpDirnOwnpabsTblGuid : NDOTest
8622	{
8623	····PersistenceManager pm;
8624	····NDOMapping mapping;
8625	····Class ownClass;
8626	····Class otherClass;
8627	····Class ownDerivedClass;
8628	····[SetUp]
8629	····public void Setup()
8630	····{
8631	········this.pm = PmFactory.NewPersistenceManager();
8632	········this.mapping = pm.NDOMapping;
8633	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsTblGuidLeftBase" );
8634	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsTblGuidRight" );
8635	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsTblGuidLeftDerived" );
8636	····}
8637	····[Test]
8638	····public void HasMappingTable()
8639	····{
8640	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
8641	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
8642	····}
8643	····[Test]
8644	····public void HasTypeColumn()
8645	····{
8646	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
8647	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
8648	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
8649	····}
8650	····[Test]
8651	····public void HasTypeCode()
8652	····{
8653	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8654	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8655	····}
8656	}
8657
8658
8659	[TestFixture]
8660	public class MappingTestCmpBin1OwnpabsNoTblGuid : NDOTest
8661	{
8662	····PersistenceManager pm;
8663	····NDOMapping mapping;
8664	····Class ownClass;
8665	····Class otherClass;
8666	····Class ownDerivedClass;
8667	····[SetUp]
8668	····public void Setup()
8669	····{
8670	········this.pm = PmFactory.NewPersistenceManager();
8671	········this.mapping = pm.NDOMapping;
8672	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsNoTblGuidLeftBase" );
8673	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsNoTblGuidRight" );
8674	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsNoTblGuidLeftDerived" );
8675	····}
8676	····[Test]
8677	····public void HasMappingTable()
8678	····{
8679	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
8680	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
8681	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
8682	····}
8683	····[Test]
8684	····public void HasTypeColumn()
8685	····{
8686	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
8687	····}
8688	····[Test]
8689	····public void HasTypeCode()
8690	····{
8691	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8692	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8693	····}
8694	}
8695
8696
8697	[TestFixture]
8698	public class MappingTestCmpBin1OwnpabsTblGuid : NDOTest
8699	{
8700	····PersistenceManager pm;
8701	····NDOMapping mapping;
8702	····Class ownClass;
8703	····Class otherClass;
8704	····Class ownDerivedClass;
8705	····[SetUp]
8706	····public void Setup()
8707	····{
8708	········this.pm = PmFactory.NewPersistenceManager();
8709	········this.mapping = pm.NDOMapping;
8710	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsTblGuidLeftBase" );
8711	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsTblGuidRight" );
8712	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsTblGuidLeftDerived" );
8713	····}
8714	····[Test]
8715	····public void HasMappingTable()
8716	····{
8717	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
8718	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
8719	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
8720	····}
8721	····[Test]
8722	····public void HasTypeColumn()
8723	····{
8724	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
8725	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
8726	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
8727	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
8728	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
8729	····}
8730	····[Test]
8731	····public void HasTypeCode()
8732	····{
8733	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8734	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8735	····}
8736	}
8737
8738
8739	[TestFixture]
8740	public class MappingTestCmpBi1nOwnpabsTblGuid : NDOTest
8741	{
8742	····PersistenceManager pm;
8743	····NDOMapping mapping;
8744	····Class ownClass;
8745	····Class otherClass;
8746	····Class ownDerivedClass;
8747	····[SetUp]
8748	····public void Setup()
8749	····{
8750	········this.pm = PmFactory.NewPersistenceManager();
8751	········this.mapping = pm.NDOMapping;
8752	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsTblGuidLeftBase" );
8753	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsTblGuidRight" );
8754	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsTblGuidLeftDerived" );
8755	····}
8756	····[Test]
8757	····public void HasMappingTable()
8758	····{
8759	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
8760	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
8761	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
8762	····}
8763	····[Test]
8764	····public void HasTypeColumn()
8765	····{
8766	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
8767	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
8768	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
8769	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
8770	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
8771	····}
8772	····[Test]
8773	····public void HasTypeCode()
8774	····{
8775	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8776	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8777	····}
8778	}
8779
8780
8781	[TestFixture]
8782	public class MappingTestCmpBinnOwnpabsTblGuid : NDOTest
8783	{
8784	····PersistenceManager pm;
8785	····NDOMapping mapping;
8786	····Class ownClass;
8787	····Class otherClass;
8788	····Class ownDerivedClass;
8789	····[SetUp]
8790	····public void Setup()
8791	····{
8792	········this.pm = PmFactory.NewPersistenceManager();
8793	········this.mapping = pm.NDOMapping;
8794	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsTblGuidLeftBase" );
8795	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsTblGuidRight" );
8796	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsTblGuidLeftDerived" );
8797	····}
8798	····[Test]
8799	····public void HasMappingTable()
8800	····{
8801	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
8802	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
8803	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
8804	····}
8805	····[Test]
8806	····public void HasTypeColumn()
8807	····{
8808	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
8809	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
8810	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
8811	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
8812	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
8813	····}
8814	····[Test]
8815	····public void HasTypeCode()
8816	····{
8817	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8818	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8819	····}
8820	}
8821
8822
8823	[TestFixture]
8824	public class MappingTestAgrDir1OthpabsNoTblGuid : NDOTest
8825	{
8826	····PersistenceManager pm;
8827	····NDOMapping mapping;
8828	····Class ownClass;
8829	····Class otherClass;
8830	····Class otherDerivedClass;
8831	····[SetUp]
8832	····public void Setup()
8833	····{
8834	········this.pm = PmFactory.NewPersistenceManager();
8835	········this.mapping = pm.NDOMapping;
8836	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsNoTblGuidLeft" );
8837	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsNoTblGuidRightBase" );
8838	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsNoTblGuidRightDerived" );
8839	····}
8840	····[Test]
8841	····public void HasMappingTable()
8842	····{
8843	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
8844	····}
8845	····[Test]
8846	····public void HasTypeColumn()
8847	····{
8848	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
8849	····}
8850	····[Test]
8851	····public void HasTypeCode()
8852	····{
8853	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
8854	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
8855	····}
8856	}
8857
8858
8859	[TestFixture]
8860	public class MappingTestAgrDir1OthpabsTblGuid : NDOTest
8861	{
8862	····PersistenceManager pm;
8863	····NDOMapping mapping;
8864	····Class ownClass;
8865	····Class otherClass;
8866	····Class otherDerivedClass;
8867	····[SetUp]
8868	····public void Setup()
8869	····{
8870	········this.pm = PmFactory.NewPersistenceManager();
8871	········this.mapping = pm.NDOMapping;
8872	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsTblGuidLeft" );
8873	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsTblGuidRightBase" );
8874	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsTblGuidRightDerived" );
8875	····}
8876	····[Test]
8877	····public void HasMappingTable()
8878	····{
8879	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
8880	····}
8881	····[Test]
8882	····public void HasTypeColumn()
8883	····{
8884	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
8885	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
8886	····}
8887	····[Test]
8888	····public void HasTypeCode()
8889	····{
8890	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
8891	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
8892	····}
8893	}
8894
8895
8896	[TestFixture]
8897	public class MappingTestAgrBi11OthpabsNoTblGuid : NDOTest
8898	{
8899	····PersistenceManager pm;
8900	····NDOMapping mapping;
8901	····Class ownClass;
8902	····Class otherClass;
8903	····Class otherDerivedClass;
8904	····[SetUp]
8905	····public void Setup()
8906	····{
8907	········this.pm = PmFactory.NewPersistenceManager();
8908	········this.mapping = pm.NDOMapping;
8909	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsNoTblGuidLeft" );
8910	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsNoTblGuidRightBase" );
8911	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsNoTblGuidRightDerived" );
8912	····}
8913	····[Test]
8914	····public void HasMappingTable()
8915	····{
8916	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
8917	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
8918	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
8919	····}
8920	····[Test]
8921	····public void HasTypeColumn()
8922	····{
8923	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
8924	····}
8925	····[Test]
8926	····public void HasTypeCode()
8927	····{
8928	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
8929	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
8930	····}
8931	}
8932
8933
8934	[TestFixture]
8935	public class MappingTestAgrBi11OthpabsTblGuid : NDOTest
8936	{
8937	····PersistenceManager pm;
8938	····NDOMapping mapping;
8939	····Class ownClass;
8940	····Class otherClass;
8941	····Class otherDerivedClass;
8942	····[SetUp]
8943	····public void Setup()
8944	····{
8945	········this.pm = PmFactory.NewPersistenceManager();
8946	········this.mapping = pm.NDOMapping;
8947	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsTblGuidLeft" );
8948	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsTblGuidRightBase" );
8949	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsTblGuidRightDerived" );
8950	····}
8951	····[Test]
8952	····public void HasMappingTable()
8953	····{
8954	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
8955	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
8956	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
8957	····}
8958	····[Test]
8959	····public void HasTypeColumn()
8960	····{
8961	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
8962	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
8963	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
8964	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
8965	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
8966	····}
8967	····[Test]
8968	····public void HasTypeCode()
8969	····{
8970	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
8971	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
8972	····}
8973	}
8974
8975
8976	[TestFixture]
8977	public class MappingTestAgrDirnOthpabsTblGuid : NDOTest
8978	{
8979	····PersistenceManager pm;
8980	····NDOMapping mapping;
8981	····Class ownClass;
8982	····Class otherClass;
8983	····Class otherDerivedClass;
8984	····[SetUp]
8985	····public void Setup()
8986	····{
8987	········this.pm = PmFactory.NewPersistenceManager();
8988	········this.mapping = pm.NDOMapping;
8989	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpabsTblGuidLeft" );
8990	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpabsTblGuidRightBase" );
8991	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpabsTblGuidRightDerived" );
8992	····}
8993	····[Test]
8994	····public void HasMappingTable()
8995	····{
8996	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
8997	····}
8998	····[Test]
8999	····public void HasTypeColumn()
9000	····{
9001	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
9002	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
9003	····}
9004	····[Test]
9005	····public void HasTypeCode()
9006	····{
9007	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9008	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9009	····}
9010	}
9011
9012
9013	[TestFixture]
9014	public class MappingTestAgrBin1OthpabsTblGuid : NDOTest
9015	{
9016	····PersistenceManager pm;
9017	····NDOMapping mapping;
9018	····Class ownClass;
9019	····Class otherClass;
9020	····Class otherDerivedClass;
9021	····[SetUp]
9022	····public void Setup()
9023	····{
9024	········this.pm = PmFactory.NewPersistenceManager();
9025	········this.mapping = pm.NDOMapping;
9026	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpabsTblGuidLeft" );
9027	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpabsTblGuidRightBase" );
9028	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpabsTblGuidRightDerived" );
9029	····}
9030	····[Test]
9031	····public void HasMappingTable()
9032	····{
9033	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
9034	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
9035	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
9036	····}
9037	····[Test]
9038	····public void HasTypeColumn()
9039	····{
9040	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
9041	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
9042	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
9043	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
9044	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
9045	····}
9046	····[Test]
9047	····public void HasTypeCode()
9048	····{
9049	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9050	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9051	····}
9052	}
9053
9054
9055	[TestFixture]
9056	public class MappingTestAgrBi1nOthpabsNoTblGuid : NDOTest
9057	{
9058	····PersistenceManager pm;
9059	····NDOMapping mapping;
9060	····Class ownClass;
9061	····Class otherClass;
9062	····Class otherDerivedClass;
9063	····[SetUp]
9064	····public void Setup()
9065	····{
9066	········this.pm = PmFactory.NewPersistenceManager();
9067	········this.mapping = pm.NDOMapping;
9068	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsNoTblGuidLeft" );
9069	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsNoTblGuidRightBase" );
9070	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsNoTblGuidRightDerived" );
9071	····}
9072	····[Test]
9073	····public void HasMappingTable()
9074	····{
9075	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
9076	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
9077	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
9078	····}
9079	····[Test]
9080	····public void HasTypeColumn()
9081	····{
9082	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
9083	····}
9084	····[Test]
9085	····public void HasTypeCode()
9086	····{
9087	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9088	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9089	····}
9090	}
9091
9092
9093	[TestFixture]
9094	public class MappingTestAgrBi1nOthpabsTblGuid : NDOTest
9095	{
9096	····PersistenceManager pm;
9097	····NDOMapping mapping;
9098	····Class ownClass;
9099	····Class otherClass;
9100	····Class otherDerivedClass;
9101	····[SetUp]
9102	····public void Setup()
9103	····{
9104	········this.pm = PmFactory.NewPersistenceManager();
9105	········this.mapping = pm.NDOMapping;
9106	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsTblGuidLeft" );
9107	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsTblGuidRightBase" );
9108	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsTblGuidRightDerived" );
9109	····}
9110	····[Test]
9111	····public void HasMappingTable()
9112	····{
9113	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
9114	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
9115	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
9116	····}
9117	····[Test]
9118	····public void HasTypeColumn()
9119	····{
9120	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
9121	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
9122	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
9123	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
9124	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
9125	····}
9126	····[Test]
9127	····public void HasTypeCode()
9128	····{
9129	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9130	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9131	····}
9132	}
9133
9134
9135	[TestFixture]
9136	public class MappingTestAgrBinnOthpabsTblGuid : NDOTest
9137	{
9138	····PersistenceManager pm;
9139	····NDOMapping mapping;
9140	····Class ownClass;
9141	····Class otherClass;
9142	····Class otherDerivedClass;
9143	····[SetUp]
9144	····public void Setup()
9145	····{
9146	········this.pm = PmFactory.NewPersistenceManager();
9147	········this.mapping = pm.NDOMapping;
9148	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpabsTblGuidLeft" );
9149	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpabsTblGuidRightBase" );
9150	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpabsTblGuidRightDerived" );
9151	····}
9152	····[Test]
9153	····public void HasMappingTable()
9154	····{
9155	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
9156	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
9157	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
9158	····}
9159	····[Test]
9160	····public void HasTypeColumn()
9161	····{
9162	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
9163	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
9164	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
9165	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
9166	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
9167	····}
9168	····[Test]
9169	····public void HasTypeCode()
9170	····{
9171	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9172	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9173	····}
9174	}
9175
9176
9177	[TestFixture]
9178	public class MappingTestCmpDir1OthpabsNoTblGuid : NDOTest
9179	{
9180	····PersistenceManager pm;
9181	····NDOMapping mapping;
9182	····Class ownClass;
9183	····Class otherClass;
9184	····Class otherDerivedClass;
9185	····[SetUp]
9186	····public void Setup()
9187	····{
9188	········this.pm = PmFactory.NewPersistenceManager();
9189	········this.mapping = pm.NDOMapping;
9190	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsNoTblGuidLeft" );
9191	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsNoTblGuidRightBase" );
9192	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsNoTblGuidRightDerived" );
9193	····}
9194	····[Test]
9195	····public void HasMappingTable()
9196	····{
9197	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
9198	····}
9199	····[Test]
9200	····public void HasTypeColumn()
9201	····{
9202	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
9203	····}
9204	····[Test]
9205	····public void HasTypeCode()
9206	····{
9207	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9208	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9209	····}
9210	}
9211
9212
9213	[TestFixture]
9214	public class MappingTestCmpDir1OthpabsTblGuid : NDOTest
9215	{
9216	····PersistenceManager pm;
9217	····NDOMapping mapping;
9218	····Class ownClass;
9219	····Class otherClass;
9220	····Class otherDerivedClass;
9221	····[SetUp]
9222	····public void Setup()
9223	····{
9224	········this.pm = PmFactory.NewPersistenceManager();
9225	········this.mapping = pm.NDOMapping;
9226	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsTblGuidLeft" );
9227	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsTblGuidRightBase" );
9228	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsTblGuidRightDerived" );
9229	····}
9230	····[Test]
9231	····public void HasMappingTable()
9232	····{
9233	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
9234	····}
9235	····[Test]
9236	····public void HasTypeColumn()
9237	····{
9238	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
9239	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
9240	····}
9241	····[Test]
9242	····public void HasTypeCode()
9243	····{
9244	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9245	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9246	····}
9247	}
9248
9249
9250	[TestFixture]
9251	public class MappingTestCmpBi11OthpabsNoTblGuid : NDOTest
9252	{
9253	····PersistenceManager pm;
9254	····NDOMapping mapping;
9255	····Class ownClass;
9256	····Class otherClass;
9257	····Class otherDerivedClass;
9258	····[SetUp]
9259	····public void Setup()
9260	····{
9261	········this.pm = PmFactory.NewPersistenceManager();
9262	········this.mapping = pm.NDOMapping;
9263	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsNoTblGuidLeft" );
9264	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsNoTblGuidRightBase" );
9265	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsNoTblGuidRightDerived" );
9266	····}
9267	····[Test]
9268	····public void HasMappingTable()
9269	····{
9270	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
9271	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
9272	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
9273	····}
9274	····[Test]
9275	····public void HasTypeColumn()
9276	····{
9277	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
9278	····}
9279	····[Test]
9280	····public void HasTypeCode()
9281	····{
9282	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9283	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9284	····}
9285	}
9286
9287
9288	[TestFixture]
9289	public class MappingTestCmpBi11OthpabsTblGuid : NDOTest
9290	{
9291	····PersistenceManager pm;
9292	····NDOMapping mapping;
9293	····Class ownClass;
9294	····Class otherClass;
9295	····Class otherDerivedClass;
9296	····[SetUp]
9297	····public void Setup()
9298	····{
9299	········this.pm = PmFactory.NewPersistenceManager();
9300	········this.mapping = pm.NDOMapping;
9301	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsTblGuidLeft" );
9302	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsTblGuidRightBase" );
9303	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsTblGuidRightDerived" );
9304	····}
9305	····[Test]
9306	····public void HasMappingTable()
9307	····{
9308	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
9309	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
9310	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
9311	····}
9312	····[Test]
9313	····public void HasTypeColumn()
9314	····{
9315	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
9316	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
9317	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
9318	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
9319	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
9320	····}
9321	····[Test]
9322	····public void HasTypeCode()
9323	····{
9324	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9325	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9326	····}
9327	}
9328
9329
9330	[TestFixture]
9331	public class MappingTestCmpDirnOthpabsTblGuid : NDOTest
9332	{
9333	····PersistenceManager pm;
9334	····NDOMapping mapping;
9335	····Class ownClass;
9336	····Class otherClass;
9337	····Class otherDerivedClass;
9338	····[SetUp]
9339	····public void Setup()
9340	····{
9341	········this.pm = PmFactory.NewPersistenceManager();
9342	········this.mapping = pm.NDOMapping;
9343	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpabsTblGuidLeft" );
9344	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpabsTblGuidRightBase" );
9345	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpabsTblGuidRightDerived" );
9346	····}
9347	····[Test]
9348	····public void HasMappingTable()
9349	····{
9350	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
9351	····}
9352	····[Test]
9353	····public void HasTypeColumn()
9354	····{
9355	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
9356	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
9357	····}
9358	····[Test]
9359	····public void HasTypeCode()
9360	····{
9361	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9362	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9363	····}
9364	}
9365
9366
9367	[TestFixture]
9368	public class MappingTestCmpBin1OthpabsTblGuid : NDOTest
9369	{
9370	····PersistenceManager pm;
9371	····NDOMapping mapping;
9372	····Class ownClass;
9373	····Class otherClass;
9374	····Class otherDerivedClass;
9375	····[SetUp]
9376	····public void Setup()
9377	····{
9378	········this.pm = PmFactory.NewPersistenceManager();
9379	········this.mapping = pm.NDOMapping;
9380	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpabsTblGuidLeft" );
9381	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpabsTblGuidRightBase" );
9382	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpabsTblGuidRightDerived" );
9383	····}
9384	····[Test]
9385	····public void HasMappingTable()
9386	····{
9387	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
9388	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
9389	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
9390	····}
9391	····[Test]
9392	····public void HasTypeColumn()
9393	····{
9394	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
9395	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
9396	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
9397	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
9398	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
9399	····}
9400	····[Test]
9401	····public void HasTypeCode()
9402	····{
9403	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9404	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9405	····}
9406	}
9407
9408
9409	[TestFixture]
9410	public class MappingTestCmpBi1nOthpabsNoTblGuid : NDOTest
9411	{
9412	····PersistenceManager pm;
9413	····NDOMapping mapping;
9414	····Class ownClass;
9415	····Class otherClass;
9416	····Class otherDerivedClass;
9417	····[SetUp]
9418	····public void Setup()
9419	····{
9420	········this.pm = PmFactory.NewPersistenceManager();
9421	········this.mapping = pm.NDOMapping;
9422	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsNoTblGuidLeft" );
9423	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsNoTblGuidRightBase" );
9424	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsNoTblGuidRightDerived" );
9425	····}
9426	····[Test]
9427	····public void HasMappingTable()
9428	····{
9429	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
9430	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
9431	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
9432	····}
9433	····[Test]
9434	····public void HasTypeColumn()
9435	····{
9436	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
9437	····}
9438	····[Test]
9439	····public void HasTypeCode()
9440	····{
9441	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9442	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9443	····}
9444	}
9445
9446
9447	[TestFixture]
9448	public class MappingTestCmpBi1nOthpabsTblGuid : NDOTest
9449	{
9450	····PersistenceManager pm;
9451	····NDOMapping mapping;
9452	····Class ownClass;
9453	····Class otherClass;
9454	····Class otherDerivedClass;
9455	····[SetUp]
9456	····public void Setup()
9457	····{
9458	········this.pm = PmFactory.NewPersistenceManager();
9459	········this.mapping = pm.NDOMapping;
9460	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsTblGuidLeft" );
9461	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsTblGuidRightBase" );
9462	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsTblGuidRightDerived" );
9463	····}
9464	····[Test]
9465	····public void HasMappingTable()
9466	····{
9467	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
9468	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
9469	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
9470	····}
9471	····[Test]
9472	····public void HasTypeColumn()
9473	····{
9474	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
9475	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
9476	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
9477	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
9478	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
9479	····}
9480	····[Test]
9481	····public void HasTypeCode()
9482	····{
9483	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9484	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9485	····}
9486	}
9487
9488
9489	[TestFixture]
9490	public class MappingTestCmpBinnOthpabsTblGuid : NDOTest
9491	{
9492	····PersistenceManager pm;
9493	····NDOMapping mapping;
9494	····Class ownClass;
9495	····Class otherClass;
9496	····Class otherDerivedClass;
9497	····[SetUp]
9498	····public void Setup()
9499	····{
9500	········this.pm = PmFactory.NewPersistenceManager();
9501	········this.mapping = pm.NDOMapping;
9502	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpabsTblGuidLeft" );
9503	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpabsTblGuidRightBase" );
9504	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpabsTblGuidRightDerived" );
9505	····}
9506	····[Test]
9507	····public void HasMappingTable()
9508	····{
9509	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
9510	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
9511	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
9512	····}
9513	····[Test]
9514	····public void HasTypeColumn()
9515	····{
9516	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
9517	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
9518	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
9519	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
9520	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
9521	····}
9522	····[Test]
9523	····public void HasTypeCode()
9524	····{
9525	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9526	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9527	····}
9528	}
9529
9530
9531	[TestFixture]
9532	public class MappingTestAgrDir1OwnpabsOthpabsNoTblGuid : NDOTest
9533	{
9534	····PersistenceManager pm;
9535	····NDOMapping mapping;
9536	····Class ownClass;
9537	····Class otherClass;
9538	····Class ownDerivedClass;
9539	····Class otherDerivedClass;
9540	····[SetUp]
9541	····public void Setup()
9542	····{
9543	········this.pm = PmFactory.NewPersistenceManager();
9544	········this.mapping = pm.NDOMapping;
9545	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsNoTblGuidLeftBase" );
9546	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsNoTblGuidRightBase" );
9547	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsNoTblGuidLeftDerived" );
9548	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsNoTblGuidRightDerived" );
9549	····}
9550	····[Test]
9551	····public void HasMappingTable()
9552	····{
9553	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
9554	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
9555	····}
9556	····[Test]
9557	····public void HasTypeColumn()
9558	····{
9559	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
9560	····}
9561	····[Test]
9562	····public void HasTypeCode()
9563	····{
9564	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9565	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9566	····}
9567	}
9568
9569
9570	[TestFixture]
9571	public class MappingTestAgrDir1OwnpabsOthpabsTblGuid : NDOTest
9572	{
9573	····PersistenceManager pm;
9574	····NDOMapping mapping;
9575	····Class ownClass;
9576	····Class otherClass;
9577	····Class ownDerivedClass;
9578	····Class otherDerivedClass;
9579	····[SetUp]
9580	····public void Setup()
9581	····{
9582	········this.pm = PmFactory.NewPersistenceManager();
9583	········this.mapping = pm.NDOMapping;
9584	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsTblGuidLeftBase" );
9585	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsTblGuidRightBase" );
9586	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsTblGuidLeftDerived" );
9587	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsTblGuidRightDerived" );
9588	····}
9589	····[Test]
9590	····public void HasMappingTable()
9591	····{
9592	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
9593	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
9594	····}
9595	····[Test]
9596	····public void HasTypeColumn()
9597	····{
9598	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
9599	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
9600	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
9601	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
9602	····}
9603	····[Test]
9604	····public void HasTypeCode()
9605	····{
9606	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9607	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9608	····}
9609	}
9610
9611
9612	[TestFixture]
9613	public class MappingTestAgrBi11OwnpabsOthpabsNoTblGuid : NDOTest
9614	{
9615	····PersistenceManager pm;
9616	····NDOMapping mapping;
9617	····Class ownClass;
9618	····Class otherClass;
9619	····Class ownDerivedClass;
9620	····Class otherDerivedClass;
9621	····[SetUp]
9622	····public void Setup()
9623	····{
9624	········this.pm = PmFactory.NewPersistenceManager();
9625	········this.mapping = pm.NDOMapping;
9626	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsNoTblGuidLeftBase" );
9627	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsNoTblGuidRightBase" );
9628	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsNoTblGuidLeftDerived" );
9629	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsNoTblGuidRightDerived" );
9630	····}
9631	····[Test]
9632	····public void HasMappingTable()
9633	····{
9634	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
9635	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
9636	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
9637	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
9638	····}
9639	····[Test]
9640	····public void HasTypeColumn()
9641	····{
9642	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
9643	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #10");
9644	····}
9645	····[Test]
9646	····public void HasTypeCode()
9647	····{
9648	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9649	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9650	····}
9651	}
9652
9653
9654	[TestFixture]
9655	public class MappingTestAgrBi11OwnpabsOthpabsTblGuid : NDOTest
9656	{
9657	····PersistenceManager pm;
9658	····NDOMapping mapping;
9659	····Class ownClass;
9660	····Class otherClass;
9661	····Class ownDerivedClass;
9662	····Class otherDerivedClass;
9663	····[SetUp]
9664	····public void Setup()
9665	····{
9666	········this.pm = PmFactory.NewPersistenceManager();
9667	········this.mapping = pm.NDOMapping;
9668	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsTblGuidLeftBase" );
9669	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsTblGuidRightBase" );
9670	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsTblGuidLeftDerived" );
9671	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsTblGuidRightDerived" );
9672	····}
9673	····[Test]
9674	····public void HasMappingTable()
9675	····{
9676	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
9677	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
9678	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
9679	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
9680	····}
9681	····[Test]
9682	····public void HasTypeColumn()
9683	····{
9684	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
9685	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
9686	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
9687	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
9688	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
9689	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
9690	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
9691	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
9692	····}
9693	····[Test]
9694	····public void HasTypeCode()
9695	····{
9696	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9697	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9698	····}
9699	}
9700
9701
9702	[TestFixture]
9703	public class MappingTestAgrDirnOwnpabsOthpabsTblGuid : NDOTest
9704	{
9705	····PersistenceManager pm;
9706	····NDOMapping mapping;
9707	····Class ownClass;
9708	····Class otherClass;
9709	····Class ownDerivedClass;
9710	····Class otherDerivedClass;
9711	····[SetUp]
9712	····public void Setup()
9713	····{
9714	········this.pm = PmFactory.NewPersistenceManager();
9715	········this.mapping = pm.NDOMapping;
9716	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsOthpabsTblGuidLeftBase" );
9717	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsOthpabsTblGuidRightBase" );
9718	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsOthpabsTblGuidLeftDerived" );
9719	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsOthpabsTblGuidRightDerived" );
9720	····}
9721	····[Test]
9722	····public void HasMappingTable()
9723	····{
9724	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
9725	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
9726	····}
9727	····[Test]
9728	····public void HasTypeColumn()
9729	····{
9730	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
9731	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
9732	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
9733	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
9734	····}
9735	····[Test]
9736	····public void HasTypeCode()
9737	····{
9738	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9739	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9740	····}
9741	}
9742
9743
9744	[TestFixture]
9745	public class MappingTestAgrBin1OwnpabsOthpabsTblGuid : NDOTest
9746	{
9747	····PersistenceManager pm;
9748	····NDOMapping mapping;
9749	····Class ownClass;
9750	····Class otherClass;
9751	····Class ownDerivedClass;
9752	····Class otherDerivedClass;
9753	····[SetUp]
9754	····public void Setup()
9755	····{
9756	········this.pm = PmFactory.NewPersistenceManager();
9757	········this.mapping = pm.NDOMapping;
9758	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsOthpabsTblGuidLeftBase" );
9759	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsOthpabsTblGuidRightBase" );
9760	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsOthpabsTblGuidLeftDerived" );
9761	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsOthpabsTblGuidRightDerived" );
9762	····}
9763	····[Test]
9764	····public void HasMappingTable()
9765	····{
9766	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
9767	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
9768	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
9769	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
9770	····}
9771	····[Test]
9772	····public void HasTypeColumn()
9773	····{
9774	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
9775	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
9776	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
9777	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
9778	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
9779	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
9780	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
9781	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
9782	····}
9783	····[Test]
9784	····public void HasTypeCode()
9785	····{
9786	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9787	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9788	····}
9789	}
9790
9791
9792	[TestFixture]
9793	public class MappingTestAgrBi1nOwnpabsOthpabsTblGuid : NDOTest
9794	{
9795	····PersistenceManager pm;
9796	····NDOMapping mapping;
9797	····Class ownClass;
9798	····Class otherClass;
9799	····Class ownDerivedClass;
9800	····Class otherDerivedClass;
9801	····[SetUp]
9802	····public void Setup()
9803	····{
9804	········this.pm = PmFactory.NewPersistenceManager();
9805	········this.mapping = pm.NDOMapping;
9806	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsOthpabsTblGuidLeftBase" );
9807	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsOthpabsTblGuidRightBase" );
9808	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsOthpabsTblGuidLeftDerived" );
9809	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsOthpabsTblGuidRightDerived" );
9810	····}
9811	····[Test]
9812	····public void HasMappingTable()
9813	····{
9814	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
9815	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
9816	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
9817	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
9818	····}
9819	····[Test]
9820	····public void HasTypeColumn()
9821	····{
9822	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
9823	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
9824	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
9825	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
9826	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
9827	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
9828	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
9829	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
9830	····}
9831	····[Test]
9832	····public void HasTypeCode()
9833	····{
9834	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9835	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9836	····}
9837	}
9838
9839
9840	[TestFixture]
9841	public class MappingTestAgrBinnOwnpabsOthpabsTblGuid : NDOTest
9842	{
9843	····PersistenceManager pm;
9844	····NDOMapping mapping;
9845	····Class ownClass;
9846	····Class otherClass;
9847	····Class ownDerivedClass;
9848	····Class otherDerivedClass;
9849	····[SetUp]
9850	····public void Setup()
9851	····{
9852	········this.pm = PmFactory.NewPersistenceManager();
9853	········this.mapping = pm.NDOMapping;
9854	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsOthpabsTblGuidLeftBase" );
9855	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsOthpabsTblGuidRightBase" );
9856	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsOthpabsTblGuidLeftDerived" );
9857	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsOthpabsTblGuidRightDerived" );
9858	····}
9859	····[Test]
9860	····public void HasMappingTable()
9861	····{
9862	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
9863	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
9864	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
9865	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
9866	····}
9867	····[Test]
9868	····public void HasTypeColumn()
9869	····{
9870	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
9871	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
9872	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
9873	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
9874	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
9875	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
9876	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
9877	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
9878	····}
9879	····[Test]
9880	····public void HasTypeCode()
9881	····{
9882	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9883	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9884	····}
9885	}
9886
9887
9888	[TestFixture]
9889	public class MappingTestCmpDir1OwnpabsOthpabsNoTblGuid : NDOTest
9890	{
9891	····PersistenceManager pm;
9892	····NDOMapping mapping;
9893	····Class ownClass;
9894	····Class otherClass;
9895	····Class ownDerivedClass;
9896	····Class otherDerivedClass;
9897	····[SetUp]
9898	····public void Setup()
9899	····{
9900	········this.pm = PmFactory.NewPersistenceManager();
9901	········this.mapping = pm.NDOMapping;
9902	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsNoTblGuidLeftBase" );
9903	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsNoTblGuidRightBase" );
9904	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsNoTblGuidLeftDerived" );
9905	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsNoTblGuidRightDerived" );
9906	····}
9907	····[Test]
9908	····public void HasMappingTable()
9909	····{
9910	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
9911	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
9912	····}
9913	····[Test]
9914	····public void HasTypeColumn()
9915	····{
9916	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
9917	····}
9918	····[Test]
9919	····public void HasTypeCode()
9920	····{
9921	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9922	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9923	····}
9924	}
9925
9926
9927	[TestFixture]
9928	public class MappingTestCmpDir1OwnpabsOthpabsTblGuid : NDOTest
9929	{
9930	····PersistenceManager pm;
9931	····NDOMapping mapping;
9932	····Class ownClass;
9933	····Class otherClass;
9934	····Class ownDerivedClass;
9935	····Class otherDerivedClass;
9936	····[SetUp]
9937	····public void Setup()
9938	····{
9939	········this.pm = PmFactory.NewPersistenceManager();
9940	········this.mapping = pm.NDOMapping;
9941	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsTblGuidLeftBase" );
9942	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsTblGuidRightBase" );
9943	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsTblGuidLeftDerived" );
9944	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsTblGuidRightDerived" );
9945	····}
9946	····[Test]
9947	····public void HasMappingTable()
9948	····{
9949	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
9950	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
9951	····}
9952	····[Test]
9953	····public void HasTypeColumn()
9954	····{
9955	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
9956	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
9957	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
9958	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
9959	····}
9960	····[Test]
9961	····public void HasTypeCode()
9962	····{
9963	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9964	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9965	····}
9966	}
9967
9968
9969	[TestFixture]
9970	public class MappingTestCmpBi11OwnpabsOthpabsNoTblGuid : NDOTest
9971	{
9972	····PersistenceManager pm;
9973	····NDOMapping mapping;
9974	····Class ownClass;
9975	····Class otherClass;
9976	····Class ownDerivedClass;
9977	····Class otherDerivedClass;
9978	····[SetUp]
9979	····public void Setup()
9980	····{
9981	········this.pm = PmFactory.NewPersistenceManager();
9982	········this.mapping = pm.NDOMapping;
9983	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsNoTblGuidLeftBase" );
9984	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsNoTblGuidRightBase" );
9985	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsNoTblGuidLeftDerived" );
9986	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsNoTblGuidRightDerived" );
9987	····}
9988	····[Test]
9989	····public void HasMappingTable()
9990	····{
9991	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
9992	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
9993	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
9994	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
9995	····}
9996	····[Test]
9997	····public void HasTypeColumn()
9998	····{
9999	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
10000	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #10");
10001	····}
10002	····[Test]
10003	····public void HasTypeCode()
10004	····{
10005	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
10006	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
10007	····}
10008	}
10009
10010
10011	[TestFixture]
10012	public class MappingTestCmpBi11OwnpabsOthpabsTblGuid : NDOTest
10013	{
10014	····PersistenceManager pm;
10015	····NDOMapping mapping;
10016	····Class ownClass;
10017	····Class otherClass;
10018	····Class ownDerivedClass;
10019	····Class otherDerivedClass;
10020	····[SetUp]
10021	····public void Setup()
10022	····{
10023	········this.pm = PmFactory.NewPersistenceManager();
10024	········this.mapping = pm.NDOMapping;
10025	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsTblGuidLeftBase" );
10026	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsTblGuidRightBase" );
10027	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsTblGuidLeftDerived" );
10028	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsTblGuidRightDerived" );
10029	····}
10030	····[Test]
10031	····public void HasMappingTable()
10032	····{
10033	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
10034	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
10035	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
10036	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
10037	····}
10038	····[Test]
10039	····public void HasTypeColumn()
10040	····{
10041	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
10042	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
10043	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
10044	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
10045	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
10046	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
10047	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
10048	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
10049	····}
10050	····[Test]
10051	····public void HasTypeCode()
10052	····{
10053	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
10054	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
10055	····}
10056	}
10057
10058
10059	[TestFixture]
10060	public class MappingTestCmpDirnOwnpabsOthpabsTblGuid : NDOTest
10061	{
10062	····PersistenceManager pm;
10063	····NDOMapping mapping;
10064	····Class ownClass;
10065	····Class otherClass;
10066	····Class ownDerivedClass;
10067	····Class otherDerivedClass;
10068	····[SetUp]
10069	····public void Setup()
10070	····{
10071	········this.pm = PmFactory.NewPersistenceManager();
10072	········this.mapping = pm.NDOMapping;
10073	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsOthpabsTblGuidLeftBase" );
10074	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsOthpabsTblGuidRightBase" );
10075	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsOthpabsTblGuidLeftDerived" );
10076	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsOthpabsTblGuidRightDerived" );
10077	····}
10078	····[Test]
10079	····public void HasMappingTable()
10080	····{
10081	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
10082	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
10083	····}
10084	····[Test]
10085	····public void HasTypeColumn()
10086	····{
10087	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
10088	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
10089	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
10090	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
10091	····}
10092	····[Test]
10093	····public void HasTypeCode()
10094	····{
10095	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
10096	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
10097	····}
10098	}
10099
10100
10101	[TestFixture]
10102	public class MappingTestCmpBin1OwnpabsOthpabsTblGuid : NDOTest
10103	{
10104	····PersistenceManager pm;
10105	····NDOMapping mapping;
10106	····Class ownClass;
10107	····Class otherClass;
10108	····Class ownDerivedClass;
10109	····Class otherDerivedClass;
10110	····[SetUp]
10111	····public void Setup()
10112	····{
10113	········this.pm = PmFactory.NewPersistenceManager();
10114	········this.mapping = pm.NDOMapping;
10115	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsOthpabsTblGuidLeftBase" );
10116	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsOthpabsTblGuidRightBase" );
10117	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsOthpabsTblGuidLeftDerived" );
10118	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsOthpabsTblGuidRightDerived" );
10119	····}
10120	····[Test]
10121	····public void HasMappingTable()
10122	····{
10123	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
10124	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
10125	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
10126	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
10127	····}
10128	····[Test]
10129	····public void HasTypeColumn()
10130	····{
10131	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
10132	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
10133	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
10134	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
10135	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
10136	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
10137	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
10138	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
10139	····}
10140	····[Test]
10141	····public void HasTypeCode()
10142	····{
10143	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
10144	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
10145	····}
10146	}
10147
10148
10149	[TestFixture]
10150	public class MappingTestCmpBi1nOwnpabsOthpabsTblGuid : NDOTest
10151	{
10152	····PersistenceManager pm;
10153	····NDOMapping mapping;
10154	····Class ownClass;
10155	····Class otherClass;
10156	····Class ownDerivedClass;
10157	····Class otherDerivedClass;
10158	····[SetUp]
10159	····public void Setup()
10160	····{
10161	········this.pm = PmFactory.NewPersistenceManager();
10162	········this.mapping = pm.NDOMapping;
10163	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsOthpabsTblGuidLeftBase" );
10164	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsOthpabsTblGuidRightBase" );
10165	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsOthpabsTblGuidLeftDerived" );
10166	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsOthpabsTblGuidRightDerived" );
10167	····}
10168	····[Test]
10169	····public void HasMappingTable()
10170	····{
10171	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
10172	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
10173	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
10174	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
10175	····}
10176	····[Test]
10177	····public void HasTypeColumn()
10178	····{
10179	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
10180	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
10181	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
10182	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
10183	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
10184	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
10185	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
10186	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
10187	····}
10188	····[Test]
10189	····public void HasTypeCode()
10190	····{
10191	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
10192	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
10193	····}
10194	}
10195
10196
10197	[TestFixture]
10198	public class MappingTestCmpBinnOwnpabsOthpabsTblGuid : NDOTest
10199	{
10200	····PersistenceManager pm;
10201	····NDOMapping mapping;
10202	····Class ownClass;
10203	····Class otherClass;
10204	····Class ownDerivedClass;
10205	····Class otherDerivedClass;
10206	····[SetUp]
10207	····public void Setup()
10208	····{
10209	········this.pm = PmFactory.NewPersistenceManager();
10210	········this.mapping = pm.NDOMapping;
10211	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsOthpabsTblGuidLeftBase" );
10212	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsOthpabsTblGuidRightBase" );
10213	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsOthpabsTblGuidLeftDerived" );
10214	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsOthpabsTblGuidRightDerived" );
10215	····}
10216	····[Test]
10217	····public void HasMappingTable()
10218	····{
10219	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
10220	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
10221	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
10222	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
10223	····}
10224	····[Test]
10225	····public void HasTypeColumn()
10226	····{
10227	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
10228	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
10229	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
10230	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
10231	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
10232	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
10233	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
10234	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
10235	····}
10236	····[Test]
10237	····public void HasTypeCode()
10238	····{
10239	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
10240	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
10241	····}
10242	}
10243
10244
10245
10246	}
10247

New Commit (36bb808)

1	//
2	// Copyright (c) 2002-2019 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.Linq;
25	using System.Diagnostics;
26	using System.Collections;
27	using System.Collections.Generic;
28	using NDO;
29	using NDO.Mapping;
30	using NUnit.Framework;
31	using NdoUnitTests;
32
33	namespace MappingUnitTests
34	{
35
36	public class PmFactory
37	{
38	····static PersistenceManager pm;
39	····public static PersistenceManager NewPersistenceManager()
40	····{
41	········if (pm == null)
42	········{
43	pm = new PersistenceManager( @"C:\Projekte\NDO5\UnitTestGenerator\UnitTests\bin\Debug\NDOMapping. xml") ;
44	········}
45	········else
46	········{
47	············pm.UnloadCache();
48	········}
49	········return pm;
50	····}
51	}
52
53
54	[TestFixture]
55	public class MappingTestAgrDir1NoTblAuto : NDOTest
56	{
57	····PersistenceManager pm;
58	····NDOMapping mapping;
59	····Class ownClass;
60	····Class otherClass;
61	····[SetUp]
62	····public void Setup()
63	····{
64	········this.pm = PmFactory.NewPersistenceManager();
65	········this.mapping = pm.NDOMapping;
66	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1NoTblAutoLeft" );
67	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1NoTblAutoRight" );
68	····}
69	····[Test]
70	····public void HasMappingTable()
71	····{
72	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
73	····}
74	····[Test]
75	····public void HasTypeColumn()
76	····{
77	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
78	····}
79	····[Test]
80	····public void HasTypeCode()
81	····{
82	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
83	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
84	····}
85	}
86
87
88	[TestFixture]
89	public class MappingTestAgrDir1TblAuto : NDOTest
90	{
91	····PersistenceManager pm;
92	····NDOMapping mapping;
93	····Class ownClass;
94	····Class otherClass;
95	····[SetUp]
96	····public void Setup()
97	····{
98	········this.pm = PmFactory.NewPersistenceManager();
99	········this.mapping = pm.NDOMapping;
100	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1TblAutoLeft" );
101	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1TblAutoRight" );
102	····}
103	····[Test]
104	····public void HasMappingTable()
105	····{
106	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
107	····}
108	····[Test]
109	····public void HasTypeColumn()
110	····{
111	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
112	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
113	····}
114	····[Test]
115	····public void HasTypeCode()
116	····{
117	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
118	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
119	····}
120	}
121
122
123	[TestFixture]
124	public class MappingTestAgrBi11NoTblAuto : NDOTest
125	{
126	····PersistenceManager pm;
127	····NDOMapping mapping;
128	····Class ownClass;
129	····Class otherClass;
130	····[SetUp]
131	····public void Setup()
132	····{
133	········this.pm = PmFactory.NewPersistenceManager();
134	········this.mapping = pm.NDOMapping;
135	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11NoTblAutoLeft" );
136	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11NoTblAutoRight" );
137	····}
138	····[Test]
139	····public void HasMappingTable()
140	····{
141	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
142	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
143	····}
144	····[Test]
145	····public void HasTypeColumn()
146	····{
147	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
148	····}
149	····[Test]
150	····public void HasTypeCode()
151	····{
152	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
153	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
154	····}
155	}
156
157
158	[TestFixture]
159	public class MappingTestAgrBi11TblAuto : NDOTest
160	{
161	····PersistenceManager pm;
162	····NDOMapping mapping;
163	····Class ownClass;
164	····Class otherClass;
165	····[SetUp]
166	····public void Setup()
167	····{
168	········this.pm = PmFactory.NewPersistenceManager();
169	········this.mapping = pm.NDOMapping;
170	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11TblAutoLeft" );
171	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11TblAutoRight" );
172	····}
173	····[Test]
174	····public void HasMappingTable()
175	····{
176	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
177	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
178	····}
179	····[Test]
180	····public void HasTypeColumn()
181	····{
182	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
183	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
184	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
185	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
186	····}
187	····[Test]
188	····public void HasTypeCode()
189	····{
190	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
191	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
192	····}
193	}
194
195
196	[TestFixture]
197	public class MappingTestAgrDirnNoTblAuto : NDOTest
198	{
199	····PersistenceManager pm;
200	····NDOMapping mapping;
201	····Class ownClass;
202	····Class otherClass;
203	····[SetUp]
204	····public void Setup()
205	····{
206	········this.pm = PmFactory.NewPersistenceManager();
207	········this.mapping = pm.NDOMapping;
208	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnNoTblAutoLeft" );
209	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnNoTblAutoRight" );
210	····}
211	····[Test]
212	····public void HasMappingTable()
213	····{
214	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
215	····}
216	····[Test]
217	····public void HasTypeColumn()
218	····{
219	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
220	····}
221	····[Test]
222	····public void HasTypeCode()
223	····{
224	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
225	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
226	····}
227	}
228
229
230	[TestFixture]
231	public class MappingTestAgrDirnTblAuto : NDOTest
232	{
233	····PersistenceManager pm;
234	····NDOMapping mapping;
235	····Class ownClass;
236	····Class otherClass;
237	····[SetUp]
238	····public void Setup()
239	····{
240	········this.pm = PmFactory.NewPersistenceManager();
241	········this.mapping = pm.NDOMapping;
242	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnTblAutoLeft" );
243	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnTblAutoRight" );
244	····}
245	····[Test]
246	····public void HasMappingTable()
247	····{
248	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
249	····}
250	····[Test]
251	····public void HasTypeColumn()
252	····{
253	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
254	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
255	····}
256	····[Test]
257	····public void HasTypeCode()
258	····{
259	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
260	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
261	····}
262	}
263
264
265	[TestFixture]
266	public class MappingTestAgrBin1NoTblAuto : NDOTest
267	{
268	····PersistenceManager pm;
269	····NDOMapping mapping;
270	····Class ownClass;
271	····Class otherClass;
272	····[SetUp]
273	····public void Setup()
274	····{
275	········this.pm = PmFactory.NewPersistenceManager();
276	········this.mapping = pm.NDOMapping;
277	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1NoTblAutoLeft" );
278	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1NoTblAutoRight" );
279	····}
280	····[Test]
281	····public void HasMappingTable()
282	····{
283	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
284	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
285	····}
286	····[Test]
287	····public void HasTypeColumn()
288	····{
289	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
290	····}
291	····[Test]
292	····public void HasTypeCode()
293	····{
294	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
295	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
296	····}
297	}
298
299
300	[TestFixture]
301	public class MappingTestAgrBin1TblAuto : NDOTest
302	{
303	····PersistenceManager pm;
304	····NDOMapping mapping;
305	····Class ownClass;
306	····Class otherClass;
307	····[SetUp]
308	····public void Setup()
309	····{
310	········this.pm = PmFactory.NewPersistenceManager();
311	········this.mapping = pm.NDOMapping;
312	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1TblAutoLeft" );
313	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1TblAutoRight" );
314	····}
315	····[Test]
316	····public void HasMappingTable()
317	····{
318	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
319	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
320	····}
321	····[Test]
322	····public void HasTypeColumn()
323	····{
324	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
325	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
326	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
327	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
328	····}
329	····[Test]
330	····public void HasTypeCode()
331	····{
332	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
333	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
334	····}
335	}
336
337
338	[TestFixture]
339	public class MappingTestAgrBi1nNoTblAuto : NDOTest
340	{
341	····PersistenceManager pm;
342	····NDOMapping mapping;
343	····Class ownClass;
344	····Class otherClass;
345	····[SetUp]
346	····public void Setup()
347	····{
348	········this.pm = PmFactory.NewPersistenceManager();
349	········this.mapping = pm.NDOMapping;
350	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nNoTblAutoLeft" );
351	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nNoTblAutoRight" );
352	····}
353	····[Test]
354	····public void HasMappingTable()
355	····{
356	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
357	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
358	····}
359	····[Test]
360	····public void HasTypeColumn()
361	····{
362	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
363	····}
364	····[Test]
365	····public void HasTypeCode()
366	····{
367	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
368	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
369	····}
370	}
371
372
373	[TestFixture]
374	public class MappingTestAgrBi1nTblAuto : NDOTest
375	{
376	····PersistenceManager pm;
377	····NDOMapping mapping;
378	····Class ownClass;
379	····Class otherClass;
380	····[SetUp]
381	····public void Setup()
382	····{
383	········this.pm = PmFactory.NewPersistenceManager();
384	········this.mapping = pm.NDOMapping;
385	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nTblAutoLeft" );
386	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nTblAutoRight" );
387	····}
388	····[Test]
389	····public void HasMappingTable()
390	····{
391	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
392	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
393	····}
394	····[Test]
395	····public void HasTypeColumn()
396	····{
397	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
398	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
399	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
400	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
401	····}
402	····[Test]
403	····public void HasTypeCode()
404	····{
405	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
406	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
407	····}
408	}
409
410
411	[TestFixture]
412	public class MappingTestAgrBinnTblAuto : NDOTest
413	{
414	····PersistenceManager pm;
415	····NDOMapping mapping;
416	····Class ownClass;
417	····Class otherClass;
418	····[SetUp]
419	····public void Setup()
420	····{
421	········this.pm = PmFactory.NewPersistenceManager();
422	········this.mapping = pm.NDOMapping;
423	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnTblAutoLeft" );
424	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnTblAutoRight" );
425	····}
426	····[Test]
427	····public void HasMappingTable()
428	····{
429	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
430	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
431	····}
432	····[Test]
433	····public void HasTypeColumn()
434	····{
435	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
436	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
437	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
438	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
439	····}
440	····[Test]
441	····public void HasTypeCode()
442	····{
443	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
444	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
445	····}
446	}
447
448
449	[TestFixture]
450	public class MappingTestCmpDir1NoTblAuto : NDOTest
451	{
452	····PersistenceManager pm;
453	····NDOMapping mapping;
454	····Class ownClass;
455	····Class otherClass;
456	····[SetUp]
457	····public void Setup()
458	····{
459	········this.pm = PmFactory.NewPersistenceManager();
460	········this.mapping = pm.NDOMapping;
461	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1NoTblAutoLeft" );
462	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1NoTblAutoRight" );
463	····}
464	····[Test]
465	····public void HasMappingTable()
466	····{
467	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
468	····}
469	····[Test]
470	····public void HasTypeColumn()
471	····{
472	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
473	····}
474	····[Test]
475	····public void HasTypeCode()
476	····{
477	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
478	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
479	····}
480	}
481
482
483	[TestFixture]
484	public class MappingTestCmpDir1TblAuto : NDOTest
485	{
486	····PersistenceManager pm;
487	····NDOMapping mapping;
488	····Class ownClass;
489	····Class otherClass;
490	····[SetUp]
491	····public void Setup()
492	····{
493	········this.pm = PmFactory.NewPersistenceManager();
494	········this.mapping = pm.NDOMapping;
495	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1TblAutoLeft" );
496	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1TblAutoRight" );
497	····}
498	····[Test]
499	····public void HasMappingTable()
500	····{
501	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
502	····}
503	····[Test]
504	····public void HasTypeColumn()
505	····{
506	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
507	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
508	····}
509	····[Test]
510	····public void HasTypeCode()
511	····{
512	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
513	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
514	····}
515	}
516
517
518	[TestFixture]
519	public class MappingTestCmpBi11NoTblAuto : NDOTest
520	{
521	····PersistenceManager pm;
522	····NDOMapping mapping;
523	····Class ownClass;
524	····Class otherClass;
525	····[SetUp]
526	····public void Setup()
527	····{
528	········this.pm = PmFactory.NewPersistenceManager();
529	········this.mapping = pm.NDOMapping;
530	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11NoTblAutoLeft" );
531	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11NoTblAutoRight" );
532	····}
533	····[Test]
534	····public void HasMappingTable()
535	····{
536	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
537	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
538	····}
539	····[Test]
540	····public void HasTypeColumn()
541	····{
542	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
543	····}
544	····[Test]
545	····public void HasTypeCode()
546	····{
547	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
548	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
549	····}
550	}
551
552
553	[TestFixture]
554	public class MappingTestCmpBi11TblAuto : NDOTest
555	{
556	····PersistenceManager pm;
557	····NDOMapping mapping;
558	····Class ownClass;
559	····Class otherClass;
560	····[SetUp]
561	····public void Setup()
562	····{
563	········this.pm = PmFactory.NewPersistenceManager();
564	········this.mapping = pm.NDOMapping;
565	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11TblAutoLeft" );
566	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11TblAutoRight" );
567	····}
568	····[Test]
569	····public void HasMappingTable()
570	····{
571	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
572	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
573	····}
574	····[Test]
575	····public void HasTypeColumn()
576	····{
577	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
578	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
579	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
580	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
581	····}
582	····[Test]
583	····public void HasTypeCode()
584	····{
585	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
586	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
587	····}
588	}
589
590
591	[TestFixture]
592	public class MappingTestCmpDirnNoTblAuto : NDOTest
593	{
594	····PersistenceManager pm;
595	····NDOMapping mapping;
596	····Class ownClass;
597	····Class otherClass;
598	····[SetUp]
599	····public void Setup()
600	····{
601	········this.pm = PmFactory.NewPersistenceManager();
602	········this.mapping = pm.NDOMapping;
603	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnNoTblAutoLeft" );
604	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnNoTblAutoRight" );
605	····}
606	····[Test]
607	····public void HasMappingTable()
608	····{
609	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
610	····}
611	····[Test]
612	····public void HasTypeColumn()
613	····{
614	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
615	····}
616	····[Test]
617	····public void HasTypeCode()
618	····{
619	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
620	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
621	····}
622	}
623
624
625	[TestFixture]
626	public class MappingTestCmpDirnTblAuto : NDOTest
627	{
628	····PersistenceManager pm;
629	····NDOMapping mapping;
630	····Class ownClass;
631	····Class otherClass;
632	····[SetUp]
633	····public void Setup()
634	····{
635	········this.pm = PmFactory.NewPersistenceManager();
636	········this.mapping = pm.NDOMapping;
637	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnTblAutoLeft" );
638	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnTblAutoRight" );
639	····}
640	····[Test]
641	····public void HasMappingTable()
642	····{
643	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
644	····}
645	····[Test]
646	····public void HasTypeColumn()
647	····{
648	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
649	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
650	····}
651	····[Test]
652	····public void HasTypeCode()
653	····{
654	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
655	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
656	····}
657	}
658
659
660	[TestFixture]
661	public class MappingTestCmpBin1NoTblAuto : NDOTest
662	{
663	····PersistenceManager pm;
664	····NDOMapping mapping;
665	····Class ownClass;
666	····Class otherClass;
667	····[SetUp]
668	····public void Setup()
669	····{
670	········this.pm = PmFactory.NewPersistenceManager();
671	········this.mapping = pm.NDOMapping;
672	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1NoTblAutoLeft" );
673	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1NoTblAutoRight" );
674	····}
675	····[Test]
676	····public void HasMappingTable()
677	····{
678	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
679	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
680	····}
681	····[Test]
682	····public void HasTypeColumn()
683	····{
684	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
685	····}
686	····[Test]
687	····public void HasTypeCode()
688	····{
689	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
690	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
691	····}
692	}
693
694
695	[TestFixture]
696	public class MappingTestCmpBin1TblAuto : NDOTest
697	{
698	····PersistenceManager pm;
699	····NDOMapping mapping;
700	····Class ownClass;
701	····Class otherClass;
702	····[SetUp]
703	····public void Setup()
704	····{
705	········this.pm = PmFactory.NewPersistenceManager();
706	········this.mapping = pm.NDOMapping;
707	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1TblAutoLeft" );
708	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1TblAutoRight" );
709	····}
710	····[Test]
711	····public void HasMappingTable()
712	····{
713	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
714	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
715	····}
716	····[Test]
717	····public void HasTypeColumn()
718	····{
719	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
720	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
721	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
722	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
723	····}
724	····[Test]
725	····public void HasTypeCode()
726	····{
727	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
728	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
729	····}
730	}
731
732
733	[TestFixture]
734	public class MappingTestCmpBi1nNoTblAuto : NDOTest
735	{
736	····PersistenceManager pm;
737	····NDOMapping mapping;
738	····Class ownClass;
739	····Class otherClass;
740	····[SetUp]
741	····public void Setup()
742	····{
743	········this.pm = PmFactory.NewPersistenceManager();
744	········this.mapping = pm.NDOMapping;
745	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nNoTblAutoLeft" );
746	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nNoTblAutoRight" );
747	····}
748	····[Test]
749	····public void HasMappingTable()
750	····{
751	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
752	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
753	····}
754	····[Test]
755	····public void HasTypeColumn()
756	····{
757	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
758	····}
759	····[Test]
760	····public void HasTypeCode()
761	····{
762	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
763	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
764	····}
765	}
766
767
768	[TestFixture]
769	public class MappingTestCmpBi1nTblAuto : NDOTest
770	{
771	····PersistenceManager pm;
772	····NDOMapping mapping;
773	····Class ownClass;
774	····Class otherClass;
775	····[SetUp]
776	····public void Setup()
777	····{
778	········this.pm = PmFactory.NewPersistenceManager();
779	········this.mapping = pm.NDOMapping;
780	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nTblAutoLeft" );
781	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nTblAutoRight" );
782	····}
783	····[Test]
784	····public void HasMappingTable()
785	····{
786	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
787	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
788	····}
789	····[Test]
790	····public void HasTypeColumn()
791	····{
792	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
793	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
794	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
795	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
796	····}
797	····[Test]
798	····public void HasTypeCode()
799	····{
800	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
801	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
802	····}
803	}
804
805
806	[TestFixture]
807	public class MappingTestCmpBinnTblAuto : NDOTest
808	{
809	····PersistenceManager pm;
810	····NDOMapping mapping;
811	····Class ownClass;
812	····Class otherClass;
813	····[SetUp]
814	····public void Setup()
815	····{
816	········this.pm = PmFactory.NewPersistenceManager();
817	········this.mapping = pm.NDOMapping;
818	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnTblAutoLeft" );
819	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnTblAutoRight" );
820	····}
821	····[Test]
822	····public void HasMappingTable()
823	····{
824	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
825	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
826	····}
827	····[Test]
828	····public void HasTypeColumn()
829	····{
830	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
831	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
832	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
833	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
834	····}
835	····[Test]
836	····public void HasTypeCode()
837	····{
838	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
839	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
840	····}
841	}
842
843
844	[TestFixture]
845	public class MappingTestAgrDir1OwnpconNoTblAuto : NDOTest
846	{
847	····PersistenceManager pm;
848	····NDOMapping mapping;
849	····Class ownClass;
850	····Class otherClass;
851	····Class ownDerivedClass;
852	····[SetUp]
853	····public void Setup()
854	····{
855	········this.pm = PmFactory.NewPersistenceManager();
856	········this.mapping = pm.NDOMapping;
857	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconNoTblAutoLeftBase" );
858	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconNoTblAutoRight" );
859	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconNoTblAutoLeftDerived" );
860	····}
861	····[Test]
862	····public void HasMappingTable()
863	····{
864	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
865	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
866	····}
867	····[Test]
868	····public void HasTypeColumn()
869	····{
870	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
871	····}
872	····[Test]
873	····public void HasTypeCode()
874	····{
875	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
876	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
877	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
878	····}
879	}
880
881
882	[TestFixture]
883	public class MappingTestAgrDir1OwnpconTblAuto : NDOTest
884	{
885	····PersistenceManager pm;
886	····NDOMapping mapping;
887	····Class ownClass;
888	····Class otherClass;
889	····Class ownDerivedClass;
890	····[SetUp]
891	····public void Setup()
892	····{
893	········this.pm = PmFactory.NewPersistenceManager();
894	········this.mapping = pm.NDOMapping;
895	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconTblAutoLeftBase" );
896	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconTblAutoRight" );
897	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconTblAutoLeftDerived" );
898	····}
899	····[Test]
900	····public void HasMappingTable()
901	····{
902	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
903	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
904	····}
905	····[Test]
906	····public void HasTypeColumn()
907	····{
908	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
909	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
910	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
911	····}
912	····[Test]
913	····public void HasTypeCode()
914	····{
915	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
916	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
917	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
918	····}
919	}
920
921
922	[TestFixture]
923	public class MappingTestAgrBi11OwnpconNoTblAuto : NDOTest
924	{
925	····PersistenceManager pm;
926	····NDOMapping mapping;
927	····Class ownClass;
928	····Class otherClass;
929	····Class ownDerivedClass;
930	····[SetUp]
931	····public void Setup()
932	····{
933	········this.pm = PmFactory.NewPersistenceManager();
934	········this.mapping = pm.NDOMapping;
935	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconNoTblAutoLeftBase" );
936	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconNoTblAutoRight" );
937	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconNoTblAutoLeftDerived" );
938	····}
939	····[Test]
940	····public void HasMappingTable()
941	····{
942	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
943	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
944	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
945	····}
946	····[Test]
947	····public void HasTypeColumn()
948	····{
949	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
950	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #10");
951	····}
952	····[Test]
953	····public void HasTypeCode()
954	····{
955	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
956	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
957	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
958	····}
959	}
960
961
962	[TestFixture]
963	public class MappingTestAgrBi11OwnpconTblAuto : NDOTest
964	{
965	····PersistenceManager pm;
966	····NDOMapping mapping;
967	····Class ownClass;
968	····Class otherClass;
969	····Class ownDerivedClass;
970	····[SetUp]
971	····public void Setup()
972	····{
973	········this.pm = PmFactory.NewPersistenceManager();
974	········this.mapping = pm.NDOMapping;
975	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconTblAutoLeftBase" );
976	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconTblAutoRight" );
977	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconTblAutoLeftDerived" );
978	····}
979	····[Test]
980	····public void HasMappingTable()
981	····{
982	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
983	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
984	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
985	····}
986	····[Test]
987	····public void HasTypeColumn()
988	····{
989	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
990	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
991	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
992	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
993	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
994	····}
995	····[Test]
996	····public void HasTypeCode()
997	····{
998	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
999	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1000	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1001	····}
1002	}
1003
1004
1005	[TestFixture]
1006	public class MappingTestAgrDirnOwnpconNoTblAuto : NDOTest
1007	{
1008	····PersistenceManager pm;
1009	····NDOMapping mapping;
1010	····Class ownClass;
1011	····Class otherClass;
1012	····Class ownDerivedClass;
1013	····[SetUp]
1014	····public void Setup()
1015	····{
1016	········this.pm = PmFactory.NewPersistenceManager();
1017	········this.mapping = pm.NDOMapping;
1018	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconNoTblAutoLeftBase" );
1019	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconNoTblAutoRight" );
1020	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconNoTblAutoLeftDerived" );
1021	····}
1022	····[Test]
1023	····public void HasMappingTable()
1024	····{
1025	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
1026	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
1027	····}
1028	····[Test]
1029	····public void HasTypeColumn()
1030	····{
1031	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
1032	····}
1033	····[Test]
1034	····public void HasTypeCode()
1035	····{
1036	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1037	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1038	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1039	····}
1040	}
1041
1042
1043	[TestFixture]
1044	public class MappingTestAgrDirnOwnpconTblAuto : NDOTest
1045	{
1046	····PersistenceManager pm;
1047	····NDOMapping mapping;
1048	····Class ownClass;
1049	····Class otherClass;
1050	····Class ownDerivedClass;
1051	····[SetUp]
1052	····public void Setup()
1053	····{
1054	········this.pm = PmFactory.NewPersistenceManager();
1055	········this.mapping = pm.NDOMapping;
1056	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconTblAutoLeftBase" );
1057	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconTblAutoRight" );
1058	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconTblAutoLeftDerived" );
1059	····}
1060	····[Test]
1061	····public void HasMappingTable()
1062	····{
1063	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
1064	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
1065	····}
1066	····[Test]
1067	····public void HasTypeColumn()
1068	····{
1069	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
1070	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
1071	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
1072	····}
1073	····[Test]
1074	····public void HasTypeCode()
1075	····{
1076	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1077	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1078	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1079	····}
1080	}
1081
1082
1083	[TestFixture]
1084	public class MappingTestAgrBin1OwnpconNoTblAuto : NDOTest
1085	{
1086	····PersistenceManager pm;
1087	····NDOMapping mapping;
1088	····Class ownClass;
1089	····Class otherClass;
1090	····Class ownDerivedClass;
1091	····[SetUp]
1092	····public void Setup()
1093	····{
1094	········this.pm = PmFactory.NewPersistenceManager();
1095	········this.mapping = pm.NDOMapping;
1096	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconNoTblAutoLeftBase" );
1097	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconNoTblAutoRight" );
1098	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconNoTblAutoLeftDerived" );
1099	····}
1100	····[Test]
1101	····public void HasMappingTable()
1102	····{
1103	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
1104	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
1105	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
1106	····}
1107	····[Test]
1108	····public void HasTypeColumn()
1109	····{
1110	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
1111	····}
1112	····[Test]
1113	····public void HasTypeCode()
1114	····{
1115	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1116	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1117	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1118	····}
1119	}
1120
1121
1122	[TestFixture]
1123	public class MappingTestAgrBin1OwnpconTblAuto : NDOTest
1124	{
1125	····PersistenceManager pm;
1126	····NDOMapping mapping;
1127	····Class ownClass;
1128	····Class otherClass;
1129	····Class ownDerivedClass;
1130	····[SetUp]
1131	····public void Setup()
1132	····{
1133	········this.pm = PmFactory.NewPersistenceManager();
1134	········this.mapping = pm.NDOMapping;
1135	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconTblAutoLeftBase" );
1136	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconTblAutoRight" );
1137	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconTblAutoLeftDerived" );
1138	····}
1139	····[Test]
1140	····public void HasMappingTable()
1141	····{
1142	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
1143	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
1144	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
1145	····}
1146	····[Test]
1147	····public void HasTypeColumn()
1148	····{
1149	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
1150	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
1151	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
1152	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
1153	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
1154	····}
1155	····[Test]
1156	····public void HasTypeCode()
1157	····{
1158	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1159	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1160	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1161	····}
1162	}
1163
1164
1165	[TestFixture]
1166	public class MappingTestAgrBi1nOwnpconTblAuto : NDOTest
1167	{
1168	····PersistenceManager pm;
1169	····NDOMapping mapping;
1170	····Class ownClass;
1171	····Class otherClass;
1172	····Class ownDerivedClass;
1173	····[SetUp]
1174	····public void Setup()
1175	····{
1176	········this.pm = PmFactory.NewPersistenceManager();
1177	········this.mapping = pm.NDOMapping;
1178	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconTblAutoLeftBase" );
1179	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconTblAutoRight" );
1180	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconTblAutoLeftDerived" );
1181	····}
1182	····[Test]
1183	····public void HasMappingTable()
1184	····{
1185	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
1186	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
1187	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
1188	····}
1189	····[Test]
1190	····public void HasTypeColumn()
1191	····{
1192	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
1193	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
1194	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
1195	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
1196	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
1197	····}
1198	····[Test]
1199	····public void HasTypeCode()
1200	····{
1201	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1202	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1203	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1204	····}
1205	}
1206
1207
1208	[TestFixture]
1209	public class MappingTestAgrBinnOwnpconTblAuto : NDOTest
1210	{
1211	····PersistenceManager pm;
1212	····NDOMapping mapping;
1213	····Class ownClass;
1214	····Class otherClass;
1215	····Class ownDerivedClass;
1216	····[SetUp]
1217	····public void Setup()
1218	····{
1219	········this.pm = PmFactory.NewPersistenceManager();
1220	········this.mapping = pm.NDOMapping;
1221	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconTblAutoLeftBase" );
1222	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconTblAutoRight" );
1223	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconTblAutoLeftDerived" );
1224	····}
1225	····[Test]
1226	····public void HasMappingTable()
1227	····{
1228	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
1229	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
1230	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
1231	····}
1232	····[Test]
1233	····public void HasTypeColumn()
1234	····{
1235	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
1236	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
1237	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
1238	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
1239	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
1240	····}
1241	····[Test]
1242	····public void HasTypeCode()
1243	····{
1244	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1245	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1246	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1247	····}
1248	}
1249
1250
1251	[TestFixture]
1252	public class MappingTestCmpDir1OwnpconNoTblAuto : NDOTest
1253	{
1254	····PersistenceManager pm;
1255	····NDOMapping mapping;
1256	····Class ownClass;
1257	····Class otherClass;
1258	····Class ownDerivedClass;
1259	····[SetUp]
1260	····public void Setup()
1261	····{
1262	········this.pm = PmFactory.NewPersistenceManager();
1263	········this.mapping = pm.NDOMapping;
1264	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconNoTblAutoLeftBase" );
1265	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconNoTblAutoRight" );
1266	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconNoTblAutoLeftDerived" );
1267	····}
1268	····[Test]
1269	····public void HasMappingTable()
1270	····{
1271	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
1272	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
1273	····}
1274	····[Test]
1275	····public void HasTypeColumn()
1276	····{
1277	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
1278	····}
1279	····[Test]
1280	····public void HasTypeCode()
1281	····{
1282	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1283	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1284	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1285	····}
1286	}
1287
1288
1289	[TestFixture]
1290	public class MappingTestCmpDir1OwnpconTblAuto : NDOTest
1291	{
1292	····PersistenceManager pm;
1293	····NDOMapping mapping;
1294	····Class ownClass;
1295	····Class otherClass;
1296	····Class ownDerivedClass;
1297	····[SetUp]
1298	····public void Setup()
1299	····{
1300	········this.pm = PmFactory.NewPersistenceManager();
1301	········this.mapping = pm.NDOMapping;
1302	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconTblAutoLeftBase" );
1303	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconTblAutoRight" );
1304	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconTblAutoLeftDerived" );
1305	····}
1306	····[Test]
1307	····public void HasMappingTable()
1308	····{
1309	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
1310	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
1311	····}
1312	····[Test]
1313	····public void HasTypeColumn()
1314	····{
1315	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
1316	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
1317	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
1318	····}
1319	····[Test]
1320	····public void HasTypeCode()
1321	····{
1322	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1323	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1324	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1325	····}
1326	}
1327
1328
1329	[TestFixture]
1330	public class MappingTestCmpBi11OwnpconNoTblAuto : NDOTest
1331	{
1332	····PersistenceManager pm;
1333	····NDOMapping mapping;
1334	····Class ownClass;
1335	····Class otherClass;
1336	····Class ownDerivedClass;
1337	····[SetUp]
1338	····public void Setup()
1339	····{
1340	········this.pm = PmFactory.NewPersistenceManager();
1341	········this.mapping = pm.NDOMapping;
1342	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconNoTblAutoLeftBase" );
1343	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconNoTblAutoRight" );
1344	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconNoTblAutoLeftDerived" );
1345	····}
1346	····[Test]
1347	····public void HasMappingTable()
1348	····{
1349	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
1350	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
1351	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
1352	····}
1353	····[Test]
1354	····public void HasTypeColumn()
1355	····{
1356	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
1357	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #10");
1358	····}
1359	····[Test]
1360	····public void HasTypeCode()
1361	····{
1362	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1363	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1364	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1365	····}
1366	}
1367
1368
1369	[TestFixture]
1370	public class MappingTestCmpBi11OwnpconTblAuto : NDOTest
1371	{
1372	····PersistenceManager pm;
1373	····NDOMapping mapping;
1374	····Class ownClass;
1375	····Class otherClass;
1376	····Class ownDerivedClass;
1377	····[SetUp]
1378	····public void Setup()
1379	····{
1380	········this.pm = PmFactory.NewPersistenceManager();
1381	········this.mapping = pm.NDOMapping;
1382	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconTblAutoLeftBase" );
1383	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconTblAutoRight" );
1384	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconTblAutoLeftDerived" );
1385	····}
1386	····[Test]
1387	····public void HasMappingTable()
1388	····{
1389	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
1390	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
1391	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
1392	····}
1393	····[Test]
1394	····public void HasTypeColumn()
1395	····{
1396	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
1397	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
1398	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
1399	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
1400	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
1401	····}
1402	····[Test]
1403	····public void HasTypeCode()
1404	····{
1405	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1406	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1407	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1408	····}
1409	}
1410
1411
1412	[TestFixture]
1413	public class MappingTestCmpDirnOwnpconNoTblAuto : NDOTest
1414	{
1415	····PersistenceManager pm;
1416	····NDOMapping mapping;
1417	····Class ownClass;
1418	····Class otherClass;
1419	····Class ownDerivedClass;
1420	····[SetUp]
1421	····public void Setup()
1422	····{
1423	········this.pm = PmFactory.NewPersistenceManager();
1424	········this.mapping = pm.NDOMapping;
1425	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconNoTblAutoLeftBase" );
1426	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconNoTblAutoRight" );
1427	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconNoTblAutoLeftDerived" );
1428	····}
1429	····[Test]
1430	····public void HasMappingTable()
1431	····{
1432	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
1433	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
1434	····}
1435	····[Test]
1436	····public void HasTypeColumn()
1437	····{
1438	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
1439	····}
1440	····[Test]
1441	····public void HasTypeCode()
1442	····{
1443	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1444	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1445	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1446	····}
1447	}
1448
1449
1450	[TestFixture]
1451	public class MappingTestCmpDirnOwnpconTblAuto : NDOTest
1452	{
1453	····PersistenceManager pm;
1454	····NDOMapping mapping;
1455	····Class ownClass;
1456	····Class otherClass;
1457	····Class ownDerivedClass;
1458	····[SetUp]
1459	····public void Setup()
1460	····{
1461	········this.pm = PmFactory.NewPersistenceManager();
1462	········this.mapping = pm.NDOMapping;
1463	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconTblAutoLeftBase" );
1464	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconTblAutoRight" );
1465	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconTblAutoLeftDerived" );
1466	····}
1467	····[Test]
1468	····public void HasMappingTable()
1469	····{
1470	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
1471	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
1472	····}
1473	····[Test]
1474	····public void HasTypeColumn()
1475	····{
1476	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
1477	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
1478	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
1479	····}
1480	····[Test]
1481	····public void HasTypeCode()
1482	····{
1483	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1484	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1485	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1486	····}
1487	}
1488
1489
1490	[TestFixture]
1491	public class MappingTestCmpBin1OwnpconNoTblAuto : NDOTest
1492	{
1493	····PersistenceManager pm;
1494	····NDOMapping mapping;
1495	····Class ownClass;
1496	····Class otherClass;
1497	····Class ownDerivedClass;
1498	····[SetUp]
1499	····public void Setup()
1500	····{
1501	········this.pm = PmFactory.NewPersistenceManager();
1502	········this.mapping = pm.NDOMapping;
1503	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconNoTblAutoLeftBase" );
1504	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconNoTblAutoRight" );
1505	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconNoTblAutoLeftDerived" );
1506	····}
1507	····[Test]
1508	····public void HasMappingTable()
1509	····{
1510	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
1511	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
1512	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
1513	····}
1514	····[Test]
1515	····public void HasTypeColumn()
1516	····{
1517	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
1518	····}
1519	····[Test]
1520	····public void HasTypeCode()
1521	····{
1522	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1523	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1524	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1525	····}
1526	}
1527
1528
1529	[TestFixture]
1530	public class MappingTestCmpBin1OwnpconTblAuto : NDOTest
1531	{
1532	····PersistenceManager pm;
1533	····NDOMapping mapping;
1534	····Class ownClass;
1535	····Class otherClass;
1536	····Class ownDerivedClass;
1537	····[SetUp]
1538	····public void Setup()
1539	····{
1540	········this.pm = PmFactory.NewPersistenceManager();
1541	········this.mapping = pm.NDOMapping;
1542	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconTblAutoLeftBase" );
1543	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconTblAutoRight" );
1544	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconTblAutoLeftDerived" );
1545	····}
1546	····[Test]
1547	····public void HasMappingTable()
1548	····{
1549	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
1550	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
1551	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
1552	····}
1553	····[Test]
1554	····public void HasTypeColumn()
1555	····{
1556	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
1557	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
1558	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
1559	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
1560	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
1561	····}
1562	····[Test]
1563	····public void HasTypeCode()
1564	····{
1565	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1566	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1567	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1568	····}
1569	}
1570
1571
1572	[TestFixture]
1573	public class MappingTestCmpBi1nOwnpconTblAuto : NDOTest
1574	{
1575	····PersistenceManager pm;
1576	····NDOMapping mapping;
1577	····Class ownClass;
1578	····Class otherClass;
1579	····Class ownDerivedClass;
1580	····[SetUp]
1581	····public void Setup()
1582	····{
1583	········this.pm = PmFactory.NewPersistenceManager();
1584	········this.mapping = pm.NDOMapping;
1585	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconTblAutoLeftBase" );
1586	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconTblAutoRight" );
1587	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconTblAutoLeftDerived" );
1588	····}
1589	····[Test]
1590	····public void HasMappingTable()
1591	····{
1592	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
1593	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
1594	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
1595	····}
1596	····[Test]
1597	····public void HasTypeColumn()
1598	····{
1599	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
1600	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
1601	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
1602	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
1603	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
1604	····}
1605	····[Test]
1606	····public void HasTypeCode()
1607	····{
1608	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1609	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1610	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1611	····}
1612	}
1613
1614
1615	[TestFixture]
1616	public class MappingTestCmpBinnOwnpconTblAuto : NDOTest
1617	{
1618	····PersistenceManager pm;
1619	····NDOMapping mapping;
1620	····Class ownClass;
1621	····Class otherClass;
1622	····Class ownDerivedClass;
1623	····[SetUp]
1624	····public void Setup()
1625	····{
1626	········this.pm = PmFactory.NewPersistenceManager();
1627	········this.mapping = pm.NDOMapping;
1628	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconTblAutoLeftBase" );
1629	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconTblAutoRight" );
1630	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconTblAutoLeftDerived" );
1631	····}
1632	····[Test]
1633	····public void HasMappingTable()
1634	····{
1635	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
1636	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
1637	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
1638	····}
1639	····[Test]
1640	····public void HasTypeColumn()
1641	····{
1642	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
1643	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
1644	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
1645	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
1646	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
1647	····}
1648	····[Test]
1649	····public void HasTypeCode()
1650	····{
1651	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1652	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1653	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1654	····}
1655	}
1656
1657
1658	[TestFixture]
1659	public class MappingTestAgrDir1OthpconNoTblAuto : NDOTest
1660	{
1661	····PersistenceManager pm;
1662	····NDOMapping mapping;
1663	····Class ownClass;
1664	····Class otherClass;
1665	····Class otherDerivedClass;
1666	····[SetUp]
1667	····public void Setup()
1668	····{
1669	········this.pm = PmFactory.NewPersistenceManager();
1670	········this.mapping = pm.NDOMapping;
1671	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconNoTblAutoLeft" );
1672	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconNoTblAutoRightBase" );
1673	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconNoTblAutoRightDerived" );
1674	····}
1675	····[Test]
1676	····public void HasMappingTable()
1677	····{
1678	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
1679	····}
1680	····[Test]
1681	····public void HasTypeColumn()
1682	····{
1683	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
1684	····}
1685	····[Test]
1686	····public void HasTypeCode()
1687	····{
1688	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1689	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1690	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
1691	····}
1692	}
1693
1694
1695	[TestFixture]
1696	public class MappingTestAgrDir1OthpconTblAuto : NDOTest
1697	{
1698	····PersistenceManager pm;
1699	····NDOMapping mapping;
1700	····Class ownClass;
1701	····Class otherClass;
1702	····Class otherDerivedClass;
1703	····[SetUp]
1704	····public void Setup()
1705	····{
1706	········this.pm = PmFactory.NewPersistenceManager();
1707	········this.mapping = pm.NDOMapping;
1708	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconTblAutoLeft" );
1709	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconTblAutoRightBase" );
1710	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconTblAutoRightDerived" );
1711	····}
1712	····[Test]
1713	····public void HasMappingTable()
1714	····{
1715	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
1716	····}
1717	····[Test]
1718	····public void HasTypeColumn()
1719	····{
1720	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
1721	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
1722	····}
1723	····[Test]
1724	····public void HasTypeCode()
1725	····{
1726	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1727	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1728	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
1729	····}
1730	}
1731
1732
1733	[TestFixture]
1734	public class MappingTestAgrBi11OthpconNoTblAuto : NDOTest
1735	{
1736	····PersistenceManager pm;
1737	····NDOMapping mapping;
1738	····Class ownClass;
1739	····Class otherClass;
1740	····Class otherDerivedClass;
1741	····[SetUp]
1742	····public void Setup()
1743	····{
1744	········this.pm = PmFactory.NewPersistenceManager();
1745	········this.mapping = pm.NDOMapping;
1746	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconNoTblAutoLeft" );
1747	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconNoTblAutoRightBase" );
1748	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconNoTblAutoRightDerived" );
1749	····}
1750	····[Test]
1751	····public void HasMappingTable()
1752	····{
1753	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
1754	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
1755	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
1756	····}
1757	····[Test]
1758	····public void HasTypeColumn()
1759	····{
1760	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
1761	····}
1762	····[Test]
1763	····public void HasTypeCode()
1764	····{
1765	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1766	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1767	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
1768	····}
1769	}
1770
1771
1772	[TestFixture]
1773	public class MappingTestAgrBi11OthpconTblAuto : NDOTest
1774	{
1775	····PersistenceManager pm;
1776	····NDOMapping mapping;
1777	····Class ownClass;
1778	····Class otherClass;
1779	····Class otherDerivedClass;
1780	····[SetUp]
1781	····public void Setup()
1782	····{
1783	········this.pm = PmFactory.NewPersistenceManager();
1784	········this.mapping = pm.NDOMapping;
1785	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconTblAutoLeft" );
1786	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconTblAutoRightBase" );
1787	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconTblAutoRightDerived" );
1788	····}
1789	····[Test]
1790	····public void HasMappingTable()
1791	····{
1792	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
1793	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
1794	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
1795	····}
1796	····[Test]
1797	····public void HasTypeColumn()
1798	····{
1799	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
1800	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
1801	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
1802	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
1803	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
1804	····}
1805	····[Test]
1806	····public void HasTypeCode()
1807	····{
1808	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1809	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1810	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
1811	····}
1812	}
1813
1814
1815	[TestFixture]
1816	public class MappingTestAgrDirnOthpconTblAuto : NDOTest
1817	{
1818	····PersistenceManager pm;
1819	····NDOMapping mapping;
1820	····Class ownClass;
1821	····Class otherClass;
1822	····Class otherDerivedClass;
1823	····[SetUp]
1824	····public void Setup()
1825	····{
1826	········this.pm = PmFactory.NewPersistenceManager();
1827	········this.mapping = pm.NDOMapping;
1828	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpconTblAutoLeft" );
1829	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpconTblAutoRightBase" );
1830	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpconTblAutoRightDerived" );
1831	····}
1832	····[Test]
1833	····public void HasMappingTable()
1834	····{
1835	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
1836	····}
1837	····[Test]
1838	····public void HasTypeColumn()
1839	····{
1840	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
1841	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
1842	····}
1843	····[Test]
1844	····public void HasTypeCode()
1845	····{
1846	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1847	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1848	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
1849	····}
1850	}
1851
1852
1853	[TestFixture]
1854	public class MappingTestAgrBin1OthpconTblAuto : NDOTest
1855	{
1856	····PersistenceManager pm;
1857	····NDOMapping mapping;
1858	····Class ownClass;
1859	····Class otherClass;
1860	····Class otherDerivedClass;
1861	····[SetUp]
1862	····public void Setup()
1863	····{
1864	········this.pm = PmFactory.NewPersistenceManager();
1865	········this.mapping = pm.NDOMapping;
1866	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpconTblAutoLeft" );
1867	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpconTblAutoRightBase" );
1868	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpconTblAutoRightDerived" );
1869	····}
1870	····[Test]
1871	····public void HasMappingTable()
1872	····{
1873	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
1874	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
1875	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
1876	····}
1877	····[Test]
1878	····public void HasTypeColumn()
1879	····{
1880	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
1881	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
1882	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
1883	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
1884	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
1885	····}
1886	····[Test]
1887	····public void HasTypeCode()
1888	····{
1889	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1890	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1891	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
1892	····}
1893	}
1894
1895
1896	[TestFixture]
1897	public class MappingTestAgrBi1nOthpconNoTblAuto : NDOTest
1898	{
1899	····PersistenceManager pm;
1900	····NDOMapping mapping;
1901	····Class ownClass;
1902	····Class otherClass;
1903	····Class otherDerivedClass;
1904	····[SetUp]
1905	····public void Setup()
1906	····{
1907	········this.pm = PmFactory.NewPersistenceManager();
1908	········this.mapping = pm.NDOMapping;
1909	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconNoTblAutoLeft" );
1910	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconNoTblAutoRightBase" );
1911	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconNoTblAutoRightDerived" );
1912	····}
1913	····[Test]
1914	····public void HasMappingTable()
1915	····{
1916	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
1917	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
1918	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
1919	····}
1920	····[Test]
1921	····public void HasTypeColumn()
1922	····{
1923	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
1924	····}
1925	····[Test]
1926	····public void HasTypeCode()
1927	····{
1928	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1929	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1930	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
1931	····}
1932	}
1933
1934
1935	[TestFixture]
1936	public class MappingTestAgrBi1nOthpconTblAuto : NDOTest
1937	{
1938	····PersistenceManager pm;
1939	····NDOMapping mapping;
1940	····Class ownClass;
1941	····Class otherClass;
1942	····Class otherDerivedClass;
1943	····[SetUp]
1944	····public void Setup()
1945	····{
1946	········this.pm = PmFactory.NewPersistenceManager();
1947	········this.mapping = pm.NDOMapping;
1948	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconTblAutoLeft" );
1949	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconTblAutoRightBase" );
1950	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconTblAutoRightDerived" );
1951	····}
1952	····[Test]
1953	····public void HasMappingTable()
1954	····{
1955	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
1956	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
1957	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
1958	····}
1959	····[Test]
1960	····public void HasTypeColumn()
1961	····{
1962	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
1963	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
1964	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
1965	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
1966	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
1967	····}
1968	····[Test]
1969	····public void HasTypeCode()
1970	····{
1971	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1972	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1973	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
1974	····}
1975	}
1976
1977
1978	[TestFixture]
1979	public class MappingTestAgrBinnOthpconTblAuto : NDOTest
1980	{
1981	····PersistenceManager pm;
1982	····NDOMapping mapping;
1983	····Class ownClass;
1984	····Class otherClass;
1985	····Class otherDerivedClass;
1986	····[SetUp]
1987	····public void Setup()
1988	····{
1989	········this.pm = PmFactory.NewPersistenceManager();
1990	········this.mapping = pm.NDOMapping;
1991	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpconTblAutoLeft" );
1992	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpconTblAutoRightBase" );
1993	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpconTblAutoRightDerived" );
1994	····}
1995	····[Test]
1996	····public void HasMappingTable()
1997	····{
1998	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
1999	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
2000	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
2001	····}
2002	····[Test]
2003	····public void HasTypeColumn()
2004	····{
2005	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2006	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
2007	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
2008	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
2009	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
2010	····}
2011	····[Test]
2012	····public void HasTypeCode()
2013	····{
2014	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2015	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2016	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2017	····}
2018	}
2019
2020
2021	[TestFixture]
2022	public class MappingTestCmpDir1OthpconTblAuto : NDOTest
2023	{
2024	····PersistenceManager pm;
2025	····NDOMapping mapping;
2026	····Class ownClass;
2027	····Class otherClass;
2028	····Class otherDerivedClass;
2029	····[SetUp]
2030	····public void Setup()
2031	····{
2032	········this.pm = PmFactory.NewPersistenceManager();
2033	········this.mapping = pm.NDOMapping;
2034	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconTblAutoLeft" );
2035	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconTblAutoRightBase" );
2036	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconTblAutoRightDerived" );
2037	····}
2038	····[Test]
2039	····public void HasMappingTable()
2040	····{
2041	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2042	····}
2043	····[Test]
2044	····public void HasTypeColumn()
2045	····{
2046	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2047	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
2048	····}
2049	····[Test]
2050	····public void HasTypeCode()
2051	····{
2052	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2053	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2054	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2055	····}
2056	}
2057
2058
2059	[TestFixture]
2060	public class MappingTestCmpBi11OthpconTblAuto : NDOTest
2061	{
2062	····PersistenceManager pm;
2063	····NDOMapping mapping;
2064	····Class ownClass;
2065	····Class otherClass;
2066	····Class otherDerivedClass;
2067	····[SetUp]
2068	····public void Setup()
2069	····{
2070	········this.pm = PmFactory.NewPersistenceManager();
2071	········this.mapping = pm.NDOMapping;
2072	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconTblAutoLeft" );
2073	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconTblAutoRightBase" );
2074	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconTblAutoRightDerived" );
2075	····}
2076	····[Test]
2077	····public void HasMappingTable()
2078	····{
2079	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2080	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
2081	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
2082	····}
2083	····[Test]
2084	····public void HasTypeColumn()
2085	····{
2086	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2087	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
2088	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
2089	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
2090	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
2091	····}
2092	····[Test]
2093	····public void HasTypeCode()
2094	····{
2095	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2096	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2097	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2098	····}
2099	}
2100
2101
2102	[TestFixture]
2103	public class MappingTestCmpDirnOthpconTblAuto : NDOTest
2104	{
2105	····PersistenceManager pm;
2106	····NDOMapping mapping;
2107	····Class ownClass;
2108	····Class otherClass;
2109	····Class otherDerivedClass;
2110	····[SetUp]
2111	····public void Setup()
2112	····{
2113	········this.pm = PmFactory.NewPersistenceManager();
2114	········this.mapping = pm.NDOMapping;
2115	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpconTblAutoLeft" );
2116	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpconTblAutoRightBase" );
2117	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpconTblAutoRightDerived" );
2118	····}
2119	····[Test]
2120	····public void HasMappingTable()
2121	····{
2122	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2123	····}
2124	····[Test]
2125	····public void HasTypeColumn()
2126	····{
2127	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2128	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
2129	····}
2130	····[Test]
2131	····public void HasTypeCode()
2132	····{
2133	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2134	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2135	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2136	····}
2137	}
2138
2139
2140	[TestFixture]
2141	public class MappingTestCmpBin1OthpconTblAuto : NDOTest
2142	{
2143	····PersistenceManager pm;
2144	····NDOMapping mapping;
2145	····Class ownClass;
2146	····Class otherClass;
2147	····Class otherDerivedClass;
2148	····[SetUp]
2149	····public void Setup()
2150	····{
2151	········this.pm = PmFactory.NewPersistenceManager();
2152	········this.mapping = pm.NDOMapping;
2153	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpconTblAutoLeft" );
2154	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpconTblAutoRightBase" );
2155	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpconTblAutoRightDerived" );
2156	····}
2157	····[Test]
2158	····public void HasMappingTable()
2159	····{
2160	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2161	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
2162	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
2163	····}
2164	····[Test]
2165	····public void HasTypeColumn()
2166	····{
2167	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2168	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
2169	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
2170	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
2171	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
2172	····}
2173	····[Test]
2174	····public void HasTypeCode()
2175	····{
2176	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2177	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2178	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2179	····}
2180	}
2181
2182
2183	[TestFixture]
2184	public class MappingTestCmpBi1nOthpconTblAuto : NDOTest
2185	{
2186	····PersistenceManager pm;
2187	····NDOMapping mapping;
2188	····Class ownClass;
2189	····Class otherClass;
2190	····Class otherDerivedClass;
2191	····[SetUp]
2192	····public void Setup()
2193	····{
2194	········this.pm = PmFactory.NewPersistenceManager();
2195	········this.mapping = pm.NDOMapping;
2196	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconTblAutoLeft" );
2197	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconTblAutoRightBase" );
2198	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconTblAutoRightDerived" );
2199	····}
2200	····[Test]
2201	····public void HasMappingTable()
2202	····{
2203	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2204	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
2205	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
2206	····}
2207	····[Test]
2208	····public void HasTypeColumn()
2209	····{
2210	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2211	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
2212	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
2213	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
2214	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
2215	····}
2216	····[Test]
2217	····public void HasTypeCode()
2218	····{
2219	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2220	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2221	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2222	····}
2223	}
2224
2225
2226	[TestFixture]
2227	public class MappingTestCmpBinnOthpconTblAuto : NDOTest
2228	{
2229	····PersistenceManager pm;
2230	····NDOMapping mapping;
2231	····Class ownClass;
2232	····Class otherClass;
2233	····Class otherDerivedClass;
2234	····[SetUp]
2235	····public void Setup()
2236	····{
2237	········this.pm = PmFactory.NewPersistenceManager();
2238	········this.mapping = pm.NDOMapping;
2239	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpconTblAutoLeft" );
2240	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpconTblAutoRightBase" );
2241	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpconTblAutoRightDerived" );
2242	····}
2243	····[Test]
2244	····public void HasMappingTable()
2245	····{
2246	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2247	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
2248	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
2249	····}
2250	····[Test]
2251	····public void HasTypeColumn()
2252	····{
2253	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2254	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
2255	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
2256	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
2257	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
2258	····}
2259	····[Test]
2260	····public void HasTypeCode()
2261	····{
2262	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2263	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2264	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2265	····}
2266	}
2267
2268
2269	[TestFixture]
2270	public class MappingTestAgrDir1OwnpconOthpconNoTblAuto : NDOTest
2271	{
2272	····PersistenceManager pm;
2273	····NDOMapping mapping;
2274	····Class ownClass;
2275	····Class otherClass;
2276	····Class ownDerivedClass;
2277	····Class otherDerivedClass;
2278	····[SetUp]
2279	····public void Setup()
2280	····{
2281	········this.pm = PmFactory.NewPersistenceManager();
2282	········this.mapping = pm.NDOMapping;
2283	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconNoTblAutoLeftBase" );
2284	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconNoTblAutoRightBase" );
2285	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconNoTblAutoLeftDerived" );
2286	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconNoTblAutoRightDerived" );
2287	····}
2288	····[Test]
2289	····public void HasMappingTable()
2290	····{
2291	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
2292	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
2293	····}
2294	····[Test]
2295	····public void HasTypeColumn()
2296	····{
2297	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
2298	····}
2299	····[Test]
2300	····public void HasTypeCode()
2301	····{
2302	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2303	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2304	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2305	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2306	····}
2307	}
2308
2309
2310	[TestFixture]
2311	public class MappingTestAgrDir1OwnpconOthpconTblAuto : NDOTest
2312	{
2313	····PersistenceManager pm;
2314	····NDOMapping mapping;
2315	····Class ownClass;
2316	····Class otherClass;
2317	····Class ownDerivedClass;
2318	····Class otherDerivedClass;
2319	····[SetUp]
2320	····public void Setup()
2321	····{
2322	········this.pm = PmFactory.NewPersistenceManager();
2323	········this.mapping = pm.NDOMapping;
2324	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconTblAutoLeftBase" );
2325	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconTblAutoRightBase" );
2326	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconTblAutoLeftDerived" );
2327	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconTblAutoRightDerived" );
2328	····}
2329	····[Test]
2330	····public void HasMappingTable()
2331	····{
2332	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2333	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
2334	····}
2335	····[Test]
2336	····public void HasTypeColumn()
2337	····{
2338	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
2339	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
2340	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2341	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
2342	····}
2343	····[Test]
2344	····public void HasTypeCode()
2345	····{
2346	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2347	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2348	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2349	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2350	····}
2351	}
2352
2353
2354	[TestFixture]
2355	public class MappingTestAgrBi11OwnpconOthpconNoTblAuto : NDOTest
2356	{
2357	····PersistenceManager pm;
2358	····NDOMapping mapping;
2359	····Class ownClass;
2360	····Class otherClass;
2361	····Class ownDerivedClass;
2362	····Class otherDerivedClass;
2363	····[SetUp]
2364	····public void Setup()
2365	····{
2366	········this.pm = PmFactory.NewPersistenceManager();
2367	········this.mapping = pm.NDOMapping;
2368	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconNoTblAutoLeftBase" );
2369	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconNoTblAutoRightBase" );
2370	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconNoTblAutoLeftDerived" );
2371	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconNoTblAutoRightDerived" );
2372	····}
2373	····[Test]
2374	····public void HasMappingTable()
2375	····{
2376	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
2377	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
2378	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
2379	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
2380	····}
2381	····[Test]
2382	····public void HasTypeColumn()
2383	····{
2384	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
2385	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #10");
2386	····}
2387	····[Test]
2388	····public void HasTypeCode()
2389	····{
2390	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2391	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2392	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2393	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2394	····}
2395	}
2396
2397
2398	[TestFixture]
2399	public class MappingTestAgrBi11OwnpconOthpconTblAuto : NDOTest
2400	{
2401	····PersistenceManager pm;
2402	····NDOMapping mapping;
2403	····Class ownClass;
2404	····Class otherClass;
2405	····Class ownDerivedClass;
2406	····Class otherDerivedClass;
2407	····[SetUp]
2408	····public void Setup()
2409	····{
2410	········this.pm = PmFactory.NewPersistenceManager();
2411	········this.mapping = pm.NDOMapping;
2412	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconTblAutoLeftBase" );
2413	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconTblAutoRightBase" );
2414	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconTblAutoLeftDerived" );
2415	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconTblAutoRightDerived" );
2416	····}
2417	····[Test]
2418	····public void HasMappingTable()
2419	····{
2420	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2421	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
2422	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
2423	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
2424	····}
2425	····[Test]
2426	····public void HasTypeColumn()
2427	····{
2428	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
2429	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
2430	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2431	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
2432	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
2433	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
2434	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
2435	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
2436	····}
2437	····[Test]
2438	····public void HasTypeCode()
2439	····{
2440	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2441	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2442	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2443	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2444	····}
2445	}
2446
2447
2448	[TestFixture]
2449	public class MappingTestAgrDirnOwnpconOthpconTblAuto : NDOTest
2450	{
2451	····PersistenceManager pm;
2452	····NDOMapping mapping;
2453	····Class ownClass;
2454	····Class otherClass;
2455	····Class ownDerivedClass;
2456	····Class otherDerivedClass;
2457	····[SetUp]
2458	····public void Setup()
2459	····{
2460	········this.pm = PmFactory.NewPersistenceManager();
2461	········this.mapping = pm.NDOMapping;
2462	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconOthpconTblAutoLeftBase" );
2463	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconOthpconTblAutoRightBase" );
2464	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconOthpconTblAutoLeftDerived" );
2465	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconOthpconTblAutoRightDerived" );
2466	····}
2467	····[Test]
2468	····public void HasMappingTable()
2469	····{
2470	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2471	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
2472	····}
2473	····[Test]
2474	····public void HasTypeColumn()
2475	····{
2476	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
2477	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
2478	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2479	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
2480	····}
2481	····[Test]
2482	····public void HasTypeCode()
2483	····{
2484	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2485	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2486	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2487	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2488	····}
2489	}
2490
2491
2492	[TestFixture]
2493	public class MappingTestAgrBin1OwnpconOthpconTblAuto : NDOTest
2494	{
2495	····PersistenceManager pm;
2496	····NDOMapping mapping;
2497	····Class ownClass;
2498	····Class otherClass;
2499	····Class ownDerivedClass;
2500	····Class otherDerivedClass;
2501	····[SetUp]
2502	····public void Setup()
2503	····{
2504	········this.pm = PmFactory.NewPersistenceManager();
2505	········this.mapping = pm.NDOMapping;
2506	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconOthpconTblAutoLeftBase" );
2507	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconOthpconTblAutoRightBase" );
2508	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconOthpconTblAutoLeftDerived" );
2509	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconOthpconTblAutoRightDerived" );
2510	····}
2511	····[Test]
2512	····public void HasMappingTable()
2513	····{
2514	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2515	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
2516	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
2517	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
2518	····}
2519	····[Test]
2520	····public void HasTypeColumn()
2521	····{
2522	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
2523	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
2524	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2525	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
2526	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
2527	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
2528	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
2529	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
2530	····}
2531	····[Test]
2532	····public void HasTypeCode()
2533	····{
2534	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2535	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2536	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2537	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2538	····}
2539	}
2540
2541
2542	[TestFixture]
2543	public class MappingTestAgrBi1nOwnpconOthpconTblAuto : NDOTest
2544	{
2545	····PersistenceManager pm;
2546	····NDOMapping mapping;
2547	····Class ownClass;
2548	····Class otherClass;
2549	····Class ownDerivedClass;
2550	····Class otherDerivedClass;
2551	····[SetUp]
2552	····public void Setup()
2553	····{
2554	········this.pm = PmFactory.NewPersistenceManager();
2555	········this.mapping = pm.NDOMapping;
2556	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconOthpconTblAutoLeftBase" );
2557	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconOthpconTblAutoRightBase" );
2558	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconOthpconTblAutoLeftDerived" );
2559	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconOthpconTblAutoRightDerived" );
2560	····}
2561	····[Test]
2562	····public void HasMappingTable()
2563	····{
2564	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2565	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
2566	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
2567	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
2568	····}
2569	····[Test]
2570	····public void HasTypeColumn()
2571	····{
2572	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
2573	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
2574	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2575	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
2576	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
2577	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
2578	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
2579	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
2580	····}
2581	····[Test]
2582	····public void HasTypeCode()
2583	····{
2584	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2585	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2586	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2587	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2588	····}
2589	}
2590
2591
2592	[TestFixture]
2593	public class MappingTestAgrBinnOwnpconOthpconTblAuto : NDOTest
2594	{
2595	····PersistenceManager pm;
2596	····NDOMapping mapping;
2597	····Class ownClass;
2598	····Class otherClass;
2599	····Class ownDerivedClass;
2600	····Class otherDerivedClass;
2601	····[SetUp]
2602	····public void Setup()
2603	····{
2604	········this.pm = PmFactory.NewPersistenceManager();
2605	········this.mapping = pm.NDOMapping;
2606	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconOthpconTblAutoLeftBase" );
2607	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconOthpconTblAutoRightBase" );
2608	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconOthpconTblAutoLeftDerived" );
2609	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconOthpconTblAutoRightDerived" );
2610	····}
2611	····[Test]
2612	····public void HasMappingTable()
2613	····{
2614	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2615	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
2616	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
2617	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
2618	····}
2619	····[Test]
2620	····public void HasTypeColumn()
2621	····{
2622	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
2623	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
2624	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2625	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
2626	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
2627	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
2628	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
2629	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
2630	····}
2631	····[Test]
2632	····public void HasTypeCode()
2633	····{
2634	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2635	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2636	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2637	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2638	····}
2639	}
2640
2641
2642	[TestFixture]
2643	public class MappingTestCmpDir1OwnpconOthpconTblAuto : NDOTest
2644	{
2645	····PersistenceManager pm;
2646	····NDOMapping mapping;
2647	····Class ownClass;
2648	····Class otherClass;
2649	····Class ownDerivedClass;
2650	····Class otherDerivedClass;
2651	····[SetUp]
2652	····public void Setup()
2653	····{
2654	········this.pm = PmFactory.NewPersistenceManager();
2655	········this.mapping = pm.NDOMapping;
2656	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconTblAutoLeftBase" );
2657	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconTblAutoRightBase" );
2658	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconTblAutoLeftDerived" );
2659	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconTblAutoRightDerived" );
2660	····}
2661	····[Test]
2662	····public void HasMappingTable()
2663	····{
2664	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2665	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
2666	····}
2667	····[Test]
2668	····public void HasTypeColumn()
2669	····{
2670	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
2671	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
2672	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2673	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
2674	····}
2675	····[Test]
2676	····public void HasTypeCode()
2677	····{
2678	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2679	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2680	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2681	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2682	····}
2683	}
2684
2685
2686	[TestFixture]
2687	public class MappingTestCmpBi11OwnpconOthpconTblAuto : NDOTest
2688	{
2689	····PersistenceManager pm;
2690	····NDOMapping mapping;
2691	····Class ownClass;
2692	····Class otherClass;
2693	····Class ownDerivedClass;
2694	····Class otherDerivedClass;
2695	····[SetUp]
2696	····public void Setup()
2697	····{
2698	········this.pm = PmFactory.NewPersistenceManager();
2699	········this.mapping = pm.NDOMapping;
2700	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconTblAutoLeftBase" );
2701	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconTblAutoRightBase" );
2702	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconTblAutoLeftDerived" );
2703	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconTblAutoRightDerived" );
2704	····}
2705	····[Test]
2706	····public void HasMappingTable()
2707	····{
2708	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2709	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
2710	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
2711	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
2712	····}
2713	····[Test]
2714	····public void HasTypeColumn()
2715	····{
2716	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
2717	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
2718	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2719	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
2720	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
2721	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
2722	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
2723	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
2724	····}
2725	····[Test]
2726	····public void HasTypeCode()
2727	····{
2728	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2729	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2730	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2731	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2732	····}
2733	}
2734
2735
2736	[TestFixture]
2737	public class MappingTestCmpDirnOwnpconOthpconTblAuto : NDOTest
2738	{
2739	····PersistenceManager pm;
2740	····NDOMapping mapping;
2741	····Class ownClass;
2742	····Class otherClass;
2743	····Class ownDerivedClass;
2744	····Class otherDerivedClass;
2745	····[SetUp]
2746	····public void Setup()
2747	····{
2748	········this.pm = PmFactory.NewPersistenceManager();
2749	········this.mapping = pm.NDOMapping;
2750	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconOthpconTblAutoLeftBase" );
2751	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconOthpconTblAutoRightBase" );
2752	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconOthpconTblAutoLeftDerived" );
2753	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconOthpconTblAutoRightDerived" );
2754	····}
2755	····[Test]
2756	····public void HasMappingTable()
2757	····{
2758	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2759	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
2760	····}
2761	····[Test]
2762	····public void HasTypeColumn()
2763	····{
2764	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
2765	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
2766	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2767	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
2768	····}
2769	····[Test]
2770	····public void HasTypeCode()
2771	····{
2772	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2773	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2774	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2775	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2776	····}
2777	}
2778
2779
2780	[TestFixture]
2781	public class MappingTestCmpBin1OwnpconOthpconTblAuto : NDOTest
2782	{
2783	····PersistenceManager pm;
2784	····NDOMapping mapping;
2785	····Class ownClass;
2786	····Class otherClass;
2787	····Class ownDerivedClass;
2788	····Class otherDerivedClass;
2789	····[SetUp]
2790	····public void Setup()
2791	····{
2792	········this.pm = PmFactory.NewPersistenceManager();
2793	········this.mapping = pm.NDOMapping;
2794	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconOthpconTblAutoLeftBase" );
2795	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconOthpconTblAutoRightBase" );
2796	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconOthpconTblAutoLeftDerived" );
2797	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconOthpconTblAutoRightDerived" );
2798	····}
2799	····[Test]
2800	····public void HasMappingTable()
2801	····{
2802	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2803	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
2804	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
2805	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
2806	····}
2807	····[Test]
2808	····public void HasTypeColumn()
2809	····{
2810	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
2811	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
2812	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2813	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
2814	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
2815	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
2816	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
2817	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
2818	····}
2819	····[Test]
2820	····public void HasTypeCode()
2821	····{
2822	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2823	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2824	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2825	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2826	····}
2827	}
2828
2829
2830	[TestFixture]
2831	public class MappingTestCmpBi1nOwnpconOthpconTblAuto : NDOTest
2832	{
2833	····PersistenceManager pm;
2834	····NDOMapping mapping;
2835	····Class ownClass;
2836	····Class otherClass;
2837	····Class ownDerivedClass;
2838	····Class otherDerivedClass;
2839	····[SetUp]
2840	····public void Setup()
2841	····{
2842	········this.pm = PmFactory.NewPersistenceManager();
2843	········this.mapping = pm.NDOMapping;
2844	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconOthpconTblAutoLeftBase" );
2845	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconOthpconTblAutoRightBase" );
2846	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconOthpconTblAutoLeftDerived" );
2847	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconOthpconTblAutoRightDerived" );
2848	····}
2849	····[Test]
2850	····public void HasMappingTable()
2851	····{
2852	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2853	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
2854	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
2855	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
2856	····}
2857	····[Test]
2858	····public void HasTypeColumn()
2859	····{
2860	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
2861	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
2862	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2863	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
2864	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
2865	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
2866	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
2867	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
2868	····}
2869	····[Test]
2870	····public void HasTypeCode()
2871	····{
2872	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2873	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2874	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2875	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2876	····}
2877	}
2878
2879
2880	[TestFixture]
2881	public class MappingTestCmpBinnOwnpconOthpconTblAuto : NDOTest
2882	{
2883	····PersistenceManager pm;
2884	····NDOMapping mapping;
2885	····Class ownClass;
2886	····Class otherClass;
2887	····Class ownDerivedClass;
2888	····Class otherDerivedClass;
2889	····[SetUp]
2890	····public void Setup()
2891	····{
2892	········this.pm = PmFactory.NewPersistenceManager();
2893	········this.mapping = pm.NDOMapping;
2894	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconOthpconTblAutoLeftBase" );
2895	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconOthpconTblAutoRightBase" );
2896	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconOthpconTblAutoLeftDerived" );
2897	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconOthpconTblAutoRightDerived" );
2898	····}
2899	····[Test]
2900	····public void HasMappingTable()
2901	····{
2902	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2903	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
2904	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
2905	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
2906	····}
2907	····[Test]
2908	····public void HasTypeColumn()
2909	····{
2910	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
2911	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
2912	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
2913	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
2914	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
2915	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
2916	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
2917	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
2918	····}
2919	····[Test]
2920	····public void HasTypeCode()
2921	····{
2922	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2923	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2924	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2925	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2926	····}
2927	}
2928
2929
2930	[TestFixture]
2931	public class MappingTestAgrDir1NoTblGuid : NDOTest
2932	{
2933	····PersistenceManager pm;
2934	····NDOMapping mapping;
2935	····Class ownClass;
2936	····Class otherClass;
2937	····[SetUp]
2938	····public void Setup()
2939	····{
2940	········this.pm = PmFactory.NewPersistenceManager();
2941	········this.mapping = pm.NDOMapping;
2942	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1NoTblGuidLeft" );
2943	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1NoTblGuidRight" );
2944	····}
2945	····[Test]
2946	····public void HasMappingTable()
2947	····{
2948	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
2949	····}
2950	····[Test]
2951	····public void HasTypeColumn()
2952	····{
2953	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
2954	····}
2955	····[Test]
2956	····public void HasTypeCode()
2957	····{
2958	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2959	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2960	····}
2961	}
2962
2963
2964	[TestFixture]
2965	public class MappingTestAgrDir1TblGuid : NDOTest
2966	{
2967	····PersistenceManager pm;
2968	····NDOMapping mapping;
2969	····Class ownClass;
2970	····Class otherClass;
2971	····[SetUp]
2972	····public void Setup()
2973	····{
2974	········this.pm = PmFactory.NewPersistenceManager();
2975	········this.mapping = pm.NDOMapping;
2976	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1TblGuidLeft" );
2977	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1TblGuidRight" );
2978	····}
2979	····[Test]
2980	····public void HasMappingTable()
2981	····{
2982	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
2983	····}
2984	····[Test]
2985	····public void HasTypeColumn()
2986	····{
2987	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
2988	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
2989	····}
2990	····[Test]
2991	····public void HasTypeCode()
2992	····{
2993	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2994	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2995	····}
2996	}
2997
2998
2999	[TestFixture]
3000	public class MappingTestAgrBi11NoTblGuid : NDOTest
3001	{
3002	····PersistenceManager pm;
3003	····NDOMapping mapping;
3004	····Class ownClass;
3005	····Class otherClass;
3006	····[SetUp]
3007	····public void Setup()
3008	····{
3009	········this.pm = PmFactory.NewPersistenceManager();
3010	········this.mapping = pm.NDOMapping;
3011	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11NoTblGuidLeft" );
3012	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11NoTblGuidRight" );
3013	····}
3014	····[Test]
3015	····public void HasMappingTable()
3016	····{
3017	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
3018	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
3019	····}
3020	····[Test]
3021	····public void HasTypeColumn()
3022	····{
3023	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3024	····}
3025	····[Test]
3026	····public void HasTypeCode()
3027	····{
3028	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3029	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3030	····}
3031	}
3032
3033
3034	[TestFixture]
3035	public class MappingTestAgrBi11TblGuid : NDOTest
3036	{
3037	····PersistenceManager pm;
3038	····NDOMapping mapping;
3039	····Class ownClass;
3040	····Class otherClass;
3041	····[SetUp]
3042	····public void Setup()
3043	····{
3044	········this.pm = PmFactory.NewPersistenceManager();
3045	········this.mapping = pm.NDOMapping;
3046	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11TblGuidLeft" );
3047	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11TblGuidRight" );
3048	····}
3049	····[Test]
3050	····public void HasMappingTable()
3051	····{
3052	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
3053	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
3054	····}
3055	····[Test]
3056	····public void HasTypeColumn()
3057	····{
3058	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3059	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
3060	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
3061	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
3062	····}
3063	····[Test]
3064	····public void HasTypeCode()
3065	····{
3066	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3067	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3068	····}
3069	}
3070
3071
3072	[TestFixture]
3073	public class MappingTestAgrDirnNoTblGuid : NDOTest
3074	{
3075	····PersistenceManager pm;
3076	····NDOMapping mapping;
3077	····Class ownClass;
3078	····Class otherClass;
3079	····[SetUp]
3080	····public void Setup()
3081	····{
3082	········this.pm = PmFactory.NewPersistenceManager();
3083	········this.mapping = pm.NDOMapping;
3084	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnNoTblGuidLeft" );
3085	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnNoTblGuidRight" );
3086	····}
3087	····[Test]
3088	····public void HasMappingTable()
3089	····{
3090	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
3091	····}
3092	····[Test]
3093	····public void HasTypeColumn()
3094	····{
3095	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3096	····}
3097	····[Test]
3098	····public void HasTypeCode()
3099	····{
3100	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3101	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3102	····}
3103	}
3104
3105
3106	[TestFixture]
3107	public class MappingTestAgrDirnTblGuid : NDOTest
3108	{
3109	····PersistenceManager pm;
3110	····NDOMapping mapping;
3111	····Class ownClass;
3112	····Class otherClass;
3113	····[SetUp]
3114	····public void Setup()
3115	····{
3116	········this.pm = PmFactory.NewPersistenceManager();
3117	········this.mapping = pm.NDOMapping;
3118	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnTblGuidLeft" );
3119	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnTblGuidRight" );
3120	····}
3121	····[Test]
3122	····public void HasMappingTable()
3123	····{
3124	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
3125	····}
3126	····[Test]
3127	····public void HasTypeColumn()
3128	····{
3129	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3130	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
3131	····}
3132	····[Test]
3133	····public void HasTypeCode()
3134	····{
3135	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3136	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3137	····}
3138	}
3139
3140
3141	[TestFixture]
3142	public class MappingTestAgrBin1NoTblGuid : NDOTest
3143	{
3144	····PersistenceManager pm;
3145	····NDOMapping mapping;
3146	····Class ownClass;
3147	····Class otherClass;
3148	····[SetUp]
3149	····public void Setup()
3150	····{
3151	········this.pm = PmFactory.NewPersistenceManager();
3152	········this.mapping = pm.NDOMapping;
3153	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1NoTblGuidLeft" );
3154	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1NoTblGuidRight" );
3155	····}
3156	····[Test]
3157	····public void HasMappingTable()
3158	····{
3159	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
3160	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
3161	····}
3162	····[Test]
3163	····public void HasTypeColumn()
3164	····{
3165	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3166	····}
3167	····[Test]
3168	····public void HasTypeCode()
3169	····{
3170	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3171	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3172	····}
3173	}
3174
3175
3176	[TestFixture]
3177	public class MappingTestAgrBin1TblGuid : NDOTest
3178	{
3179	····PersistenceManager pm;
3180	····NDOMapping mapping;
3181	····Class ownClass;
3182	····Class otherClass;
3183	····[SetUp]
3184	····public void Setup()
3185	····{
3186	········this.pm = PmFactory.NewPersistenceManager();
3187	········this.mapping = pm.NDOMapping;
3188	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1TblGuidLeft" );
3189	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1TblGuidRight" );
3190	····}
3191	····[Test]
3192	····public void HasMappingTable()
3193	····{
3194	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
3195	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
3196	····}
3197	····[Test]
3198	····public void HasTypeColumn()
3199	····{
3200	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3201	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
3202	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
3203	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
3204	····}
3205	····[Test]
3206	····public void HasTypeCode()
3207	····{
3208	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3209	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3210	····}
3211	}
3212
3213
3214	[TestFixture]
3215	public class MappingTestAgrBi1nNoTblGuid : NDOTest
3216	{
3217	····PersistenceManager pm;
3218	····NDOMapping mapping;
3219	····Class ownClass;
3220	····Class otherClass;
3221	····[SetUp]
3222	····public void Setup()
3223	····{
3224	········this.pm = PmFactory.NewPersistenceManager();
3225	········this.mapping = pm.NDOMapping;
3226	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nNoTblGuidLeft" );
3227	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nNoTblGuidRight" );
3228	····}
3229	····[Test]
3230	····public void HasMappingTable()
3231	····{
3232	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
3233	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
3234	····}
3235	····[Test]
3236	····public void HasTypeColumn()
3237	····{
3238	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3239	····}
3240	····[Test]
3241	····public void HasTypeCode()
3242	····{
3243	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3244	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3245	····}
3246	}
3247
3248
3249	[TestFixture]
3250	public class MappingTestAgrBi1nTblGuid : NDOTest
3251	{
3252	····PersistenceManager pm;
3253	····NDOMapping mapping;
3254	····Class ownClass;
3255	····Class otherClass;
3256	····[SetUp]
3257	····public void Setup()
3258	····{
3259	········this.pm = PmFactory.NewPersistenceManager();
3260	········this.mapping = pm.NDOMapping;
3261	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nTblGuidLeft" );
3262	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nTblGuidRight" );
3263	····}
3264	····[Test]
3265	····public void HasMappingTable()
3266	····{
3267	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
3268	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
3269	····}
3270	····[Test]
3271	····public void HasTypeColumn()
3272	····{
3273	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3274	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
3275	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
3276	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
3277	····}
3278	····[Test]
3279	····public void HasTypeCode()
3280	····{
3281	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3282	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3283	····}
3284	}
3285
3286
3287	[TestFixture]
3288	public class MappingTestAgrBinnTblGuid : NDOTest
3289	{
3290	····PersistenceManager pm;
3291	····NDOMapping mapping;
3292	····Class ownClass;
3293	····Class otherClass;
3294	····[SetUp]
3295	····public void Setup()
3296	····{
3297	········this.pm = PmFactory.NewPersistenceManager();
3298	········this.mapping = pm.NDOMapping;
3299	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnTblGuidLeft" );
3300	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnTblGuidRight" );
3301	····}
3302	····[Test]
3303	····public void HasMappingTable()
3304	····{
3305	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
3306	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
3307	····}
3308	····[Test]
3309	····public void HasTypeColumn()
3310	····{
3311	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3312	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
3313	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
3314	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
3315	····}
3316	····[Test]
3317	····public void HasTypeCode()
3318	····{
3319	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3320	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3321	····}
3322	}
3323
3324
3325	[TestFixture]
3326	public class MappingTestCmpDir1NoTblGuid : NDOTest
3327	{
3328	····PersistenceManager pm;
3329	····NDOMapping mapping;
3330	····Class ownClass;
3331	····Class otherClass;
3332	····[SetUp]
3333	····public void Setup()
3334	····{
3335	········this.pm = PmFactory.NewPersistenceManager();
3336	········this.mapping = pm.NDOMapping;
3337	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1NoTblGuidLeft" );
3338	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1NoTblGuidRight" );
3339	····}
3340	····[Test]
3341	····public void HasMappingTable()
3342	····{
3343	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
3344	····}
3345	····[Test]
3346	····public void HasTypeColumn()
3347	····{
3348	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3349	····}
3350	····[Test]
3351	····public void HasTypeCode()
3352	····{
3353	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3354	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3355	····}
3356	}
3357
3358
3359	[TestFixture]
3360	public class MappingTestCmpDir1TblGuid : NDOTest
3361	{
3362	····PersistenceManager pm;
3363	····NDOMapping mapping;
3364	····Class ownClass;
3365	····Class otherClass;
3366	····[SetUp]
3367	····public void Setup()
3368	····{
3369	········this.pm = PmFactory.NewPersistenceManager();
3370	········this.mapping = pm.NDOMapping;
3371	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1TblGuidLeft" );
3372	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1TblGuidRight" );
3373	····}
3374	····[Test]
3375	····public void HasMappingTable()
3376	····{
3377	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
3378	····}
3379	····[Test]
3380	····public void HasTypeColumn()
3381	····{
3382	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3383	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
3384	····}
3385	····[Test]
3386	····public void HasTypeCode()
3387	····{
3388	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3389	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3390	····}
3391	}
3392
3393
3394	[TestFixture]
3395	public class MappingTestCmpBi11NoTblGuid : NDOTest
3396	{
3397	····PersistenceManager pm;
3398	····NDOMapping mapping;
3399	····Class ownClass;
3400	····Class otherClass;
3401	····[SetUp]
3402	····public void Setup()
3403	····{
3404	········this.pm = PmFactory.NewPersistenceManager();
3405	········this.mapping = pm.NDOMapping;
3406	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11NoTblGuidLeft" );
3407	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11NoTblGuidRight" );
3408	····}
3409	····[Test]
3410	····public void HasMappingTable()
3411	····{
3412	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
3413	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
3414	····}
3415	····[Test]
3416	····public void HasTypeColumn()
3417	····{
3418	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3419	····}
3420	····[Test]
3421	····public void HasTypeCode()
3422	····{
3423	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3424	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3425	····}
3426	}
3427
3428
3429	[TestFixture]
3430	public class MappingTestCmpBi11TblGuid : NDOTest
3431	{
3432	····PersistenceManager pm;
3433	····NDOMapping mapping;
3434	····Class ownClass;
3435	····Class otherClass;
3436	····[SetUp]
3437	····public void Setup()
3438	····{
3439	········this.pm = PmFactory.NewPersistenceManager();
3440	········this.mapping = pm.NDOMapping;
3441	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11TblGuidLeft" );
3442	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11TblGuidRight" );
3443	····}
3444	····[Test]
3445	····public void HasMappingTable()
3446	····{
3447	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
3448	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
3449	····}
3450	····[Test]
3451	····public void HasTypeColumn()
3452	····{
3453	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3454	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
3455	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
3456	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
3457	····}
3458	····[Test]
3459	····public void HasTypeCode()
3460	····{
3461	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3462	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3463	····}
3464	}
3465
3466
3467	[TestFixture]
3468	public class MappingTestCmpDirnNoTblGuid : NDOTest
3469	{
3470	····PersistenceManager pm;
3471	····NDOMapping mapping;
3472	····Class ownClass;
3473	····Class otherClass;
3474	····[SetUp]
3475	····public void Setup()
3476	····{
3477	········this.pm = PmFactory.NewPersistenceManager();
3478	········this.mapping = pm.NDOMapping;
3479	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnNoTblGuidLeft" );
3480	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnNoTblGuidRight" );
3481	····}
3482	····[Test]
3483	····public void HasMappingTable()
3484	····{
3485	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
3486	····}
3487	····[Test]
3488	····public void HasTypeColumn()
3489	····{
3490	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3491	····}
3492	····[Test]
3493	····public void HasTypeCode()
3494	····{
3495	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3496	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3497	····}
3498	}
3499
3500
3501	[TestFixture]
3502	public class MappingTestCmpDirnTblGuid : NDOTest
3503	{
3504	····PersistenceManager pm;
3505	····NDOMapping mapping;
3506	····Class ownClass;
3507	····Class otherClass;
3508	····[SetUp]
3509	····public void Setup()
3510	····{
3511	········this.pm = PmFactory.NewPersistenceManager();
3512	········this.mapping = pm.NDOMapping;
3513	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnTblGuidLeft" );
3514	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnTblGuidRight" );
3515	····}
3516	····[Test]
3517	····public void HasMappingTable()
3518	····{
3519	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
3520	····}
3521	····[Test]
3522	····public void HasTypeColumn()
3523	····{
3524	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3525	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
3526	····}
3527	····[Test]
3528	····public void HasTypeCode()
3529	····{
3530	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3531	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3532	····}
3533	}
3534
3535
3536	[TestFixture]
3537	public class MappingTestCmpBin1NoTblGuid : NDOTest
3538	{
3539	····PersistenceManager pm;
3540	····NDOMapping mapping;
3541	····Class ownClass;
3542	····Class otherClass;
3543	····[SetUp]
3544	····public void Setup()
3545	····{
3546	········this.pm = PmFactory.NewPersistenceManager();
3547	········this.mapping = pm.NDOMapping;
3548	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1NoTblGuidLeft" );
3549	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1NoTblGuidRight" );
3550	····}
3551	····[Test]
3552	····public void HasMappingTable()
3553	····{
3554	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
3555	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
3556	····}
3557	····[Test]
3558	····public void HasTypeColumn()
3559	····{
3560	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3561	····}
3562	····[Test]
3563	····public void HasTypeCode()
3564	····{
3565	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3566	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3567	····}
3568	}
3569
3570
3571	[TestFixture]
3572	public class MappingTestCmpBin1TblGuid : NDOTest
3573	{
3574	····PersistenceManager pm;
3575	····NDOMapping mapping;
3576	····Class ownClass;
3577	····Class otherClass;
3578	····[SetUp]
3579	····public void Setup()
3580	····{
3581	········this.pm = PmFactory.NewPersistenceManager();
3582	········this.mapping = pm.NDOMapping;
3583	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1TblGuidLeft" );
3584	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1TblGuidRight" );
3585	····}
3586	····[Test]
3587	····public void HasMappingTable()
3588	····{
3589	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
3590	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
3591	····}
3592	····[Test]
3593	····public void HasTypeColumn()
3594	····{
3595	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3596	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
3597	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
3598	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
3599	····}
3600	····[Test]
3601	····public void HasTypeCode()
3602	····{
3603	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3604	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3605	····}
3606	}
3607
3608
3609	[TestFixture]
3610	public class MappingTestCmpBi1nNoTblGuid : NDOTest
3611	{
3612	····PersistenceManager pm;
3613	····NDOMapping mapping;
3614	····Class ownClass;
3615	····Class otherClass;
3616	····[SetUp]
3617	····public void Setup()
3618	····{
3619	········this.pm = PmFactory.NewPersistenceManager();
3620	········this.mapping = pm.NDOMapping;
3621	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nNoTblGuidLeft" );
3622	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nNoTblGuidRight" );
3623	····}
3624	····[Test]
3625	····public void HasMappingTable()
3626	····{
3627	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
3628	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
3629	····}
3630	····[Test]
3631	····public void HasTypeColumn()
3632	····{
3633	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3634	····}
3635	····[Test]
3636	····public void HasTypeCode()
3637	····{
3638	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3639	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3640	····}
3641	}
3642
3643
3644	[TestFixture]
3645	public class MappingTestCmpBi1nTblGuid : NDOTest
3646	{
3647	····PersistenceManager pm;
3648	····NDOMapping mapping;
3649	····Class ownClass;
3650	····Class otherClass;
3651	····[SetUp]
3652	····public void Setup()
3653	····{
3654	········this.pm = PmFactory.NewPersistenceManager();
3655	········this.mapping = pm.NDOMapping;
3656	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nTblGuidLeft" );
3657	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nTblGuidRight" );
3658	····}
3659	····[Test]
3660	····public void HasMappingTable()
3661	····{
3662	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
3663	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
3664	····}
3665	····[Test]
3666	····public void HasTypeColumn()
3667	····{
3668	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3669	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
3670	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
3671	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
3672	····}
3673	····[Test]
3674	····public void HasTypeCode()
3675	····{
3676	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3677	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3678	····}
3679	}
3680
3681
3682	[TestFixture]
3683	public class MappingTestCmpBinnTblGuid : NDOTest
3684	{
3685	····PersistenceManager pm;
3686	····NDOMapping mapping;
3687	····Class ownClass;
3688	····Class otherClass;
3689	····[SetUp]
3690	····public void Setup()
3691	····{
3692	········this.pm = PmFactory.NewPersistenceManager();
3693	········this.mapping = pm.NDOMapping;
3694	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnTblGuidLeft" );
3695	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnTblGuidRight" );
3696	····}
3697	····[Test]
3698	····public void HasMappingTable()
3699	····{
3700	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
3701	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
3702	····}
3703	····[Test]
3704	····public void HasTypeColumn()
3705	····{
3706	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3707	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
3708	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
3709	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
3710	····}
3711	····[Test]
3712	····public void HasTypeCode()
3713	····{
3714	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3715	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3716	····}
3717	}
3718
3719
3720	[TestFixture]
3721	public class MappingTestAgrDir1OwnpconNoTblGuid : NDOTest
3722	{
3723	····PersistenceManager pm;
3724	····NDOMapping mapping;
3725	····Class ownClass;
3726	····Class otherClass;
3727	····Class ownDerivedClass;
3728	····[SetUp]
3729	····public void Setup()
3730	····{
3731	········this.pm = PmFactory.NewPersistenceManager();
3732	········this.mapping = pm.NDOMapping;
3733	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconNoTblGuidLeftBase" );
3734	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconNoTblGuidRight" );
3735	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconNoTblGuidLeftDerived" );
3736	····}
3737	····[Test]
3738	····public void HasMappingTable()
3739	····{
3740	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
3741	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
3742	····}
3743	····[Test]
3744	····public void HasTypeColumn()
3745	····{
3746	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3747	····}
3748	····[Test]
3749	····public void HasTypeCode()
3750	····{
3751	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3752	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3753	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
3754	····}
3755	}
3756
3757
3758	[TestFixture]
3759	public class MappingTestAgrDir1OwnpconTblGuid : NDOTest
3760	{
3761	····PersistenceManager pm;
3762	····NDOMapping mapping;
3763	····Class ownClass;
3764	····Class otherClass;
3765	····Class ownDerivedClass;
3766	····[SetUp]
3767	····public void Setup()
3768	····{
3769	········this.pm = PmFactory.NewPersistenceManager();
3770	········this.mapping = pm.NDOMapping;
3771	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconTblGuidLeftBase" );
3772	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconTblGuidRight" );
3773	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconTblGuidLeftDerived" );
3774	····}
3775	····[Test]
3776	····public void HasMappingTable()
3777	····{
3778	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
3779	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
3780	····}
3781	····[Test]
3782	····public void HasTypeColumn()
3783	····{
3784	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
3785	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
3786	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
3787	····}
3788	····[Test]
3789	····public void HasTypeCode()
3790	····{
3791	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3792	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3793	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
3794	····}
3795	}
3796
3797
3798	[TestFixture]
3799	public class MappingTestAgrBi11OwnpconNoTblGuid : NDOTest
3800	{
3801	····PersistenceManager pm;
3802	····NDOMapping mapping;
3803	····Class ownClass;
3804	····Class otherClass;
3805	····Class ownDerivedClass;
3806	····[SetUp]
3807	····public void Setup()
3808	····{
3809	········this.pm = PmFactory.NewPersistenceManager();
3810	········this.mapping = pm.NDOMapping;
3811	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconNoTblGuidLeftBase" );
3812	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconNoTblGuidRight" );
3813	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconNoTblGuidLeftDerived" );
3814	····}
3815	····[Test]
3816	····public void HasMappingTable()
3817	····{
3818	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
3819	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
3820	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
3821	····}
3822	····[Test]
3823	····public void HasTypeColumn()
3824	····{
3825	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3826	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #10");
3827	····}
3828	····[Test]
3829	····public void HasTypeCode()
3830	····{
3831	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3832	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3833	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
3834	····}
3835	}
3836
3837
3838	[TestFixture]
3839	public class MappingTestAgrBi11OwnpconTblGuid : NDOTest
3840	{
3841	····PersistenceManager pm;
3842	····NDOMapping mapping;
3843	····Class ownClass;
3844	····Class otherClass;
3845	····Class ownDerivedClass;
3846	····[SetUp]
3847	····public void Setup()
3848	····{
3849	········this.pm = PmFactory.NewPersistenceManager();
3850	········this.mapping = pm.NDOMapping;
3851	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconTblGuidLeftBase" );
3852	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconTblGuidRight" );
3853	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconTblGuidLeftDerived" );
3854	····}
3855	····[Test]
3856	····public void HasMappingTable()
3857	····{
3858	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
3859	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
3860	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
3861	····}
3862	····[Test]
3863	····public void HasTypeColumn()
3864	····{
3865	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
3866	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
3867	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
3868	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
3869	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
3870	····}
3871	····[Test]
3872	····public void HasTypeCode()
3873	····{
3874	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3875	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3876	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
3877	····}
3878	}
3879
3880
3881	[TestFixture]
3882	public class MappingTestAgrDirnOwnpconNoTblGuid : NDOTest
3883	{
3884	····PersistenceManager pm;
3885	····NDOMapping mapping;
3886	····Class ownClass;
3887	····Class otherClass;
3888	····Class ownDerivedClass;
3889	····[SetUp]
3890	····public void Setup()
3891	····{
3892	········this.pm = PmFactory.NewPersistenceManager();
3893	········this.mapping = pm.NDOMapping;
3894	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconNoTblGuidLeftBase" );
3895	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconNoTblGuidRight" );
3896	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconNoTblGuidLeftDerived" );
3897	····}
3898	····[Test]
3899	····public void HasMappingTable()
3900	····{
3901	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
3902	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
3903	····}
3904	····[Test]
3905	····public void HasTypeColumn()
3906	····{
3907	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3908	····}
3909	····[Test]
3910	····public void HasTypeCode()
3911	····{
3912	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3913	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3914	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
3915	····}
3916	}
3917
3918
3919	[TestFixture]
3920	public class MappingTestAgrDirnOwnpconTblGuid : NDOTest
3921	{
3922	····PersistenceManager pm;
3923	····NDOMapping mapping;
3924	····Class ownClass;
3925	····Class otherClass;
3926	····Class ownDerivedClass;
3927	····[SetUp]
3928	····public void Setup()
3929	····{
3930	········this.pm = PmFactory.NewPersistenceManager();
3931	········this.mapping = pm.NDOMapping;
3932	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconTblGuidLeftBase" );
3933	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconTblGuidRight" );
3934	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconTblGuidLeftDerived" );
3935	····}
3936	····[Test]
3937	····public void HasMappingTable()
3938	····{
3939	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
3940	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
3941	····}
3942	····[Test]
3943	····public void HasTypeColumn()
3944	····{
3945	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
3946	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
3947	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
3948	····}
3949	····[Test]
3950	····public void HasTypeCode()
3951	····{
3952	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3953	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3954	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
3955	····}
3956	}
3957
3958
3959	[TestFixture]
3960	public class MappingTestAgrBin1OwnpconNoTblGuid : NDOTest
3961	{
3962	····PersistenceManager pm;
3963	····NDOMapping mapping;
3964	····Class ownClass;
3965	····Class otherClass;
3966	····Class ownDerivedClass;
3967	····[SetUp]
3968	····public void Setup()
3969	····{
3970	········this.pm = PmFactory.NewPersistenceManager();
3971	········this.mapping = pm.NDOMapping;
3972	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconNoTblGuidLeftBase" );
3973	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconNoTblGuidRight" );
3974	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconNoTblGuidLeftDerived" );
3975	····}
3976	····[Test]
3977	····public void HasMappingTable()
3978	····{
3979	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
3980	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
3981	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
3982	····}
3983	····[Test]
3984	····public void HasTypeColumn()
3985	····{
3986	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
3987	····}
3988	····[Test]
3989	····public void HasTypeCode()
3990	····{
3991	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3992	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3993	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
3994	····}
3995	}
3996
3997
3998	[TestFixture]
3999	public class MappingTestAgrBin1OwnpconTblGuid : NDOTest
4000	{
4001	····PersistenceManager pm;
4002	····NDOMapping mapping;
4003	····Class ownClass;
4004	····Class otherClass;
4005	····Class ownDerivedClass;
4006	····[SetUp]
4007	····public void Setup()
4008	····{
4009	········this.pm = PmFactory.NewPersistenceManager();
4010	········this.mapping = pm.NDOMapping;
4011	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconTblGuidLeftBase" );
4012	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconTblGuidRight" );
4013	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconTblGuidLeftDerived" );
4014	····}
4015	····[Test]
4016	····public void HasMappingTable()
4017	····{
4018	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
4019	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
4020	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
4021	····}
4022	····[Test]
4023	····public void HasTypeColumn()
4024	····{
4025	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
4026	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
4027	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
4028	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
4029	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
4030	····}
4031	····[Test]
4032	····public void HasTypeCode()
4033	····{
4034	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4035	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4036	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4037	····}
4038	}
4039
4040
4041	[TestFixture]
4042	public class MappingTestAgrBi1nOwnpconTblGuid : NDOTest
4043	{
4044	····PersistenceManager pm;
4045	····NDOMapping mapping;
4046	····Class ownClass;
4047	····Class otherClass;
4048	····Class ownDerivedClass;
4049	····[SetUp]
4050	····public void Setup()
4051	····{
4052	········this.pm = PmFactory.NewPersistenceManager();
4053	········this.mapping = pm.NDOMapping;
4054	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconTblGuidLeftBase" );
4055	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconTblGuidRight" );
4056	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconTblGuidLeftDerived" );
4057	····}
4058	····[Test]
4059	····public void HasMappingTable()
4060	····{
4061	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
4062	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
4063	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
4064	····}
4065	····[Test]
4066	····public void HasTypeColumn()
4067	····{
4068	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
4069	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
4070	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
4071	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
4072	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
4073	····}
4074	····[Test]
4075	····public void HasTypeCode()
4076	····{
4077	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4078	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4079	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4080	····}
4081	}
4082
4083
4084	[TestFixture]
4085	public class MappingTestAgrBinnOwnpconTblGuid : NDOTest
4086	{
4087	····PersistenceManager pm;
4088	····NDOMapping mapping;
4089	····Class ownClass;
4090	····Class otherClass;
4091	····Class ownDerivedClass;
4092	····[SetUp]
4093	····public void Setup()
4094	····{
4095	········this.pm = PmFactory.NewPersistenceManager();
4096	········this.mapping = pm.NDOMapping;
4097	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconTblGuidLeftBase" );
4098	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconTblGuidRight" );
4099	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconTblGuidLeftDerived" );
4100	····}
4101	····[Test]
4102	····public void HasMappingTable()
4103	····{
4104	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
4105	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
4106	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
4107	····}
4108	····[Test]
4109	····public void HasTypeColumn()
4110	····{
4111	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
4112	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
4113	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
4114	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
4115	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
4116	····}
4117	····[Test]
4118	····public void HasTypeCode()
4119	····{
4120	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4121	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4122	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4123	····}
4124	}
4125
4126
4127	[TestFixture]
4128	public class MappingTestCmpDir1OwnpconNoTblGuid : NDOTest
4129	{
4130	····PersistenceManager pm;
4131	····NDOMapping mapping;
4132	····Class ownClass;
4133	····Class otherClass;
4134	····Class ownDerivedClass;
4135	····[SetUp]
4136	····public void Setup()
4137	····{
4138	········this.pm = PmFactory.NewPersistenceManager();
4139	········this.mapping = pm.NDOMapping;
4140	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconNoTblGuidLeftBase" );
4141	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconNoTblGuidRight" );
4142	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconNoTblGuidLeftDerived" );
4143	····}
4144	····[Test]
4145	····public void HasMappingTable()
4146	····{
4147	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
4148	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
4149	····}
4150	····[Test]
4151	····public void HasTypeColumn()
4152	····{
4153	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
4154	····}
4155	····[Test]
4156	····public void HasTypeCode()
4157	····{
4158	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4159	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4160	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4161	····}
4162	}
4163
4164
4165	[TestFixture]
4166	public class MappingTestCmpDir1OwnpconTblGuid : NDOTest
4167	{
4168	····PersistenceManager pm;
4169	····NDOMapping mapping;
4170	····Class ownClass;
4171	····Class otherClass;
4172	····Class ownDerivedClass;
4173	····[SetUp]
4174	····public void Setup()
4175	····{
4176	········this.pm = PmFactory.NewPersistenceManager();
4177	········this.mapping = pm.NDOMapping;
4178	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconTblGuidLeftBase" );
4179	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconTblGuidRight" );
4180	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconTblGuidLeftDerived" );
4181	····}
4182	····[Test]
4183	····public void HasMappingTable()
4184	····{
4185	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
4186	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
4187	····}
4188	····[Test]
4189	····public void HasTypeColumn()
4190	····{
4191	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
4192	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
4193	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
4194	····}
4195	····[Test]
4196	····public void HasTypeCode()
4197	····{
4198	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4199	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4200	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4201	····}
4202	}
4203
4204
4205	[TestFixture]
4206	public class MappingTestCmpBi11OwnpconNoTblGuid : NDOTest
4207	{
4208	····PersistenceManager pm;
4209	····NDOMapping mapping;
4210	····Class ownClass;
4211	····Class otherClass;
4212	····Class ownDerivedClass;
4213	····[SetUp]
4214	····public void Setup()
4215	····{
4216	········this.pm = PmFactory.NewPersistenceManager();
4217	········this.mapping = pm.NDOMapping;
4218	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconNoTblGuidLeftBase" );
4219	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconNoTblGuidRight" );
4220	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconNoTblGuidLeftDerived" );
4221	····}
4222	····[Test]
4223	····public void HasMappingTable()
4224	····{
4225	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
4226	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
4227	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
4228	····}
4229	····[Test]
4230	····public void HasTypeColumn()
4231	····{
4232	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
4233	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #10");
4234	····}
4235	····[Test]
4236	····public void HasTypeCode()
4237	····{
4238	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4239	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4240	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4241	····}
4242	}
4243
4244
4245	[TestFixture]
4246	public class MappingTestCmpBi11OwnpconTblGuid : NDOTest
4247	{
4248	····PersistenceManager pm;
4249	····NDOMapping mapping;
4250	····Class ownClass;
4251	····Class otherClass;
4252	····Class ownDerivedClass;
4253	····[SetUp]
4254	····public void Setup()
4255	····{
4256	········this.pm = PmFactory.NewPersistenceManager();
4257	········this.mapping = pm.NDOMapping;
4258	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconTblGuidLeftBase" );
4259	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconTblGuidRight" );
4260	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconTblGuidLeftDerived" );
4261	····}
4262	····[Test]
4263	····public void HasMappingTable()
4264	····{
4265	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
4266	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
4267	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
4268	····}
4269	····[Test]
4270	····public void HasTypeColumn()
4271	····{
4272	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
4273	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
4274	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
4275	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
4276	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
4277	····}
4278	····[Test]
4279	····public void HasTypeCode()
4280	····{
4281	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4282	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4283	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4284	····}
4285	}
4286
4287
4288	[TestFixture]
4289	public class MappingTestCmpDirnOwnpconNoTblGuid : NDOTest
4290	{
4291	····PersistenceManager pm;
4292	····NDOMapping mapping;
4293	····Class ownClass;
4294	····Class otherClass;
4295	····Class ownDerivedClass;
4296	····[SetUp]
4297	····public void Setup()
4298	····{
4299	········this.pm = PmFactory.NewPersistenceManager();
4300	········this.mapping = pm.NDOMapping;
4301	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconNoTblGuidLeftBase" );
4302	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconNoTblGuidRight" );
4303	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconNoTblGuidLeftDerived" );
4304	····}
4305	····[Test]
4306	····public void HasMappingTable()
4307	····{
4308	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
4309	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
4310	····}
4311	····[Test]
4312	····public void HasTypeColumn()
4313	····{
4314	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
4315	····}
4316	····[Test]
4317	····public void HasTypeCode()
4318	····{
4319	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4320	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4321	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4322	····}
4323	}
4324
4325
4326	[TestFixture]
4327	public class MappingTestCmpDirnOwnpconTblGuid : NDOTest
4328	{
4329	····PersistenceManager pm;
4330	····NDOMapping mapping;
4331	····Class ownClass;
4332	····Class otherClass;
4333	····Class ownDerivedClass;
4334	····[SetUp]
4335	····public void Setup()
4336	····{
4337	········this.pm = PmFactory.NewPersistenceManager();
4338	········this.mapping = pm.NDOMapping;
4339	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconTblGuidLeftBase" );
4340	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconTblGuidRight" );
4341	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconTblGuidLeftDerived" );
4342	····}
4343	····[Test]
4344	····public void HasMappingTable()
4345	····{
4346	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
4347	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
4348	····}
4349	····[Test]
4350	····public void HasTypeColumn()
4351	····{
4352	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
4353	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
4354	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
4355	····}
4356	····[Test]
4357	····public void HasTypeCode()
4358	····{
4359	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4360	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4361	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4362	····}
4363	}
4364
4365
4366	[TestFixture]
4367	public class MappingTestCmpBin1OwnpconNoTblGuid : NDOTest
4368	{
4369	····PersistenceManager pm;
4370	····NDOMapping mapping;
4371	····Class ownClass;
4372	····Class otherClass;
4373	····Class ownDerivedClass;
4374	····[SetUp]
4375	····public void Setup()
4376	····{
4377	········this.pm = PmFactory.NewPersistenceManager();
4378	········this.mapping = pm.NDOMapping;
4379	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconNoTblGuidLeftBase" );
4380	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconNoTblGuidRight" );
4381	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconNoTblGuidLeftDerived" );
4382	····}
4383	····[Test]
4384	····public void HasMappingTable()
4385	····{
4386	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
4387	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
4388	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
4389	····}
4390	····[Test]
4391	····public void HasTypeColumn()
4392	····{
4393	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
4394	····}
4395	····[Test]
4396	····public void HasTypeCode()
4397	····{
4398	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4399	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4400	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4401	····}
4402	}
4403
4404
4405	[TestFixture]
4406	public class MappingTestCmpBin1OwnpconTblGuid : NDOTest
4407	{
4408	····PersistenceManager pm;
4409	····NDOMapping mapping;
4410	····Class ownClass;
4411	····Class otherClass;
4412	····Class ownDerivedClass;
4413	····[SetUp]
4414	····public void Setup()
4415	····{
4416	········this.pm = PmFactory.NewPersistenceManager();
4417	········this.mapping = pm.NDOMapping;
4418	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconTblGuidLeftBase" );
4419	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconTblGuidRight" );
4420	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconTblGuidLeftDerived" );
4421	····}
4422	····[Test]
4423	····public void HasMappingTable()
4424	····{
4425	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
4426	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
4427	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
4428	····}
4429	····[Test]
4430	····public void HasTypeColumn()
4431	····{
4432	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
4433	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
4434	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
4435	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
4436	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
4437	····}
4438	····[Test]
4439	····public void HasTypeCode()
4440	····{
4441	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4442	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4443	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4444	····}
4445	}
4446
4447
4448	[TestFixture]
4449	public class MappingTestCmpBi1nOwnpconTblGuid : NDOTest
4450	{
4451	····PersistenceManager pm;
4452	····NDOMapping mapping;
4453	····Class ownClass;
4454	····Class otherClass;
4455	····Class ownDerivedClass;
4456	····[SetUp]
4457	····public void Setup()
4458	····{
4459	········this.pm = PmFactory.NewPersistenceManager();
4460	········this.mapping = pm.NDOMapping;
4461	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconTblGuidLeftBase" );
4462	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconTblGuidRight" );
4463	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconTblGuidLeftDerived" );
4464	····}
4465	····[Test]
4466	····public void HasMappingTable()
4467	····{
4468	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
4469	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
4470	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
4471	····}
4472	····[Test]
4473	····public void HasTypeColumn()
4474	····{
4475	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
4476	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
4477	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
4478	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
4479	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
4480	····}
4481	····[Test]
4482	····public void HasTypeCode()
4483	····{
4484	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4485	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4486	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4487	····}
4488	}
4489
4490
4491	[TestFixture]
4492	public class MappingTestCmpBinnOwnpconTblGuid : NDOTest
4493	{
4494	····PersistenceManager pm;
4495	····NDOMapping mapping;
4496	····Class ownClass;
4497	····Class otherClass;
4498	····Class ownDerivedClass;
4499	····[SetUp]
4500	····public void Setup()
4501	····{
4502	········this.pm = PmFactory.NewPersistenceManager();
4503	········this.mapping = pm.NDOMapping;
4504	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconTblGuidLeftBase" );
4505	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconTblGuidRight" );
4506	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconTblGuidLeftDerived" );
4507	····}
4508	····[Test]
4509	····public void HasMappingTable()
4510	····{
4511	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
4512	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
4513	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
4514	····}
4515	····[Test]
4516	····public void HasTypeColumn()
4517	····{
4518	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
4519	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
4520	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
4521	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
4522	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
4523	····}
4524	····[Test]
4525	····public void HasTypeCode()
4526	····{
4527	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4528	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4529	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4530	····}
4531	}
4532
4533
4534	[TestFixture]
4535	public class MappingTestAgrDir1OthpconNoTblGuid : NDOTest
4536	{
4537	····PersistenceManager pm;
4538	····NDOMapping mapping;
4539	····Class ownClass;
4540	····Class otherClass;
4541	····Class otherDerivedClass;
4542	····[SetUp]
4543	····public void Setup()
4544	····{
4545	········this.pm = PmFactory.NewPersistenceManager();
4546	········this.mapping = pm.NDOMapping;
4547	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconNoTblGuidLeft" );
4548	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconNoTblGuidRightBase" );
4549	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconNoTblGuidRightDerived" );
4550	····}
4551	····[Test]
4552	····public void HasMappingTable()
4553	····{
4554	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
4555	····}
4556	····[Test]
4557	····public void HasTypeColumn()
4558	····{
4559	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
4560	····}
4561	····[Test]
4562	····public void HasTypeCode()
4563	····{
4564	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4565	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4566	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4567	····}
4568	}
4569
4570
4571	[TestFixture]
4572	public class MappingTestAgrDir1OthpconTblGuid : NDOTest
4573	{
4574	····PersistenceManager pm;
4575	····NDOMapping mapping;
4576	····Class ownClass;
4577	····Class otherClass;
4578	····Class otherDerivedClass;
4579	····[SetUp]
4580	····public void Setup()
4581	····{
4582	········this.pm = PmFactory.NewPersistenceManager();
4583	········this.mapping = pm.NDOMapping;
4584	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconTblGuidLeft" );
4585	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconTblGuidRightBase" );
4586	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconTblGuidRightDerived" );
4587	····}
4588	····[Test]
4589	····public void HasMappingTable()
4590	····{
4591	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
4592	····}
4593	····[Test]
4594	····public void HasTypeColumn()
4595	····{
4596	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
4597	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
4598	····}
4599	····[Test]
4600	····public void HasTypeCode()
4601	····{
4602	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4603	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4604	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4605	····}
4606	}
4607
4608
4609	[TestFixture]
4610	public class MappingTestAgrBi11OthpconNoTblGuid : NDOTest
4611	{
4612	····PersistenceManager pm;
4613	····NDOMapping mapping;
4614	····Class ownClass;
4615	····Class otherClass;
4616	····Class otherDerivedClass;
4617	····[SetUp]
4618	····public void Setup()
4619	····{
4620	········this.pm = PmFactory.NewPersistenceManager();
4621	········this.mapping = pm.NDOMapping;
4622	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconNoTblGuidLeft" );
4623	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconNoTblGuidRightBase" );
4624	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconNoTblGuidRightDerived" );
4625	····}
4626	····[Test]
4627	····public void HasMappingTable()
4628	····{
4629	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
4630	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
4631	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
4632	····}
4633	····[Test]
4634	····public void HasTypeColumn()
4635	····{
4636	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
4637	····}
4638	····[Test]
4639	····public void HasTypeCode()
4640	····{
4641	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4642	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4643	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4644	····}
4645	}
4646
4647
4648	[TestFixture]
4649	public class MappingTestAgrBi11OthpconTblGuid : NDOTest
4650	{
4651	····PersistenceManager pm;
4652	····NDOMapping mapping;
4653	····Class ownClass;
4654	····Class otherClass;
4655	····Class otherDerivedClass;
4656	····[SetUp]
4657	····public void Setup()
4658	····{
4659	········this.pm = PmFactory.NewPersistenceManager();
4660	········this.mapping = pm.NDOMapping;
4661	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconTblGuidLeft" );
4662	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconTblGuidRightBase" );
4663	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconTblGuidRightDerived" );
4664	····}
4665	····[Test]
4666	····public void HasMappingTable()
4667	····{
4668	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
4669	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
4670	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
4671	····}
4672	····[Test]
4673	····public void HasTypeColumn()
4674	····{
4675	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
4676	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
4677	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
4678	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
4679	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
4680	····}
4681	····[Test]
4682	····public void HasTypeCode()
4683	····{
4684	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4685	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4686	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4687	····}
4688	}
4689
4690
4691	[TestFixture]
4692	public class MappingTestAgrDirnOthpconTblGuid : NDOTest
4693	{
4694	····PersistenceManager pm;
4695	····NDOMapping mapping;
4696	····Class ownClass;
4697	····Class otherClass;
4698	····Class otherDerivedClass;
4699	····[SetUp]
4700	····public void Setup()
4701	····{
4702	········this.pm = PmFactory.NewPersistenceManager();
4703	········this.mapping = pm.NDOMapping;
4704	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpconTblGuidLeft" );
4705	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpconTblGuidRightBase" );
4706	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpconTblGuidRightDerived" );
4707	····}
4708	····[Test]
4709	····public void HasMappingTable()
4710	····{
4711	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
4712	····}
4713	····[Test]
4714	····public void HasTypeColumn()
4715	····{
4716	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
4717	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
4718	····}
4719	····[Test]
4720	····public void HasTypeCode()
4721	····{
4722	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4723	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4724	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4725	····}
4726	}
4727
4728
4729	[TestFixture]
4730	public class MappingTestAgrBin1OthpconTblGuid : NDOTest
4731	{
4732	····PersistenceManager pm;
4733	····NDOMapping mapping;
4734	····Class ownClass;
4735	····Class otherClass;
4736	····Class otherDerivedClass;
4737	····[SetUp]
4738	····public void Setup()
4739	····{
4740	········this.pm = PmFactory.NewPersistenceManager();
4741	········this.mapping = pm.NDOMapping;
4742	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpconTblGuidLeft" );
4743	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpconTblGuidRightBase" );
4744	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpconTblGuidRightDerived" );
4745	····}
4746	····[Test]
4747	····public void HasMappingTable()
4748	····{
4749	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
4750	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
4751	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
4752	····}
4753	····[Test]
4754	····public void HasTypeColumn()
4755	····{
4756	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
4757	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
4758	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
4759	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
4760	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
4761	····}
4762	····[Test]
4763	····public void HasTypeCode()
4764	····{
4765	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4766	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4767	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4768	····}
4769	}
4770
4771
4772	[TestFixture]
4773	public class MappingTestAgrBi1nOthpconNoTblGuid : NDOTest
4774	{
4775	····PersistenceManager pm;
4776	····NDOMapping mapping;
4777	····Class ownClass;
4778	····Class otherClass;
4779	····Class otherDerivedClass;
4780	····[SetUp]
4781	····public void Setup()
4782	····{
4783	········this.pm = PmFactory.NewPersistenceManager();
4784	········this.mapping = pm.NDOMapping;
4785	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconNoTblGuidLeft" );
4786	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconNoTblGuidRightBase" );
4787	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconNoTblGuidRightDerived" );
4788	····}
4789	····[Test]
4790	····public void HasMappingTable()
4791	····{
4792	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
4793	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
4794	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
4795	····}
4796	····[Test]
4797	····public void HasTypeColumn()
4798	····{
4799	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
4800	····}
4801	····[Test]
4802	····public void HasTypeCode()
4803	····{
4804	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4805	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4806	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4807	····}
4808	}
4809
4810
4811	[TestFixture]
4812	public class MappingTestAgrBi1nOthpconTblGuid : NDOTest
4813	{
4814	····PersistenceManager pm;
4815	····NDOMapping mapping;
4816	····Class ownClass;
4817	····Class otherClass;
4818	····Class otherDerivedClass;
4819	····[SetUp]
4820	····public void Setup()
4821	····{
4822	········this.pm = PmFactory.NewPersistenceManager();
4823	········this.mapping = pm.NDOMapping;
4824	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconTblGuidLeft" );
4825	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconTblGuidRightBase" );
4826	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconTblGuidRightDerived" );
4827	····}
4828	····[Test]
4829	····public void HasMappingTable()
4830	····{
4831	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
4832	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
4833	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
4834	····}
4835	····[Test]
4836	····public void HasTypeColumn()
4837	····{
4838	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
4839	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
4840	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
4841	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
4842	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
4843	····}
4844	····[Test]
4845	····public void HasTypeCode()
4846	····{
4847	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4848	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4849	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4850	····}
4851	}
4852
4853
4854	[TestFixture]
4855	public class MappingTestAgrBinnOthpconTblGuid : NDOTest
4856	{
4857	····PersistenceManager pm;
4858	····NDOMapping mapping;
4859	····Class ownClass;
4860	····Class otherClass;
4861	····Class otherDerivedClass;
4862	····[SetUp]
4863	····public void Setup()
4864	····{
4865	········this.pm = PmFactory.NewPersistenceManager();
4866	········this.mapping = pm.NDOMapping;
4867	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpconTblGuidLeft" );
4868	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpconTblGuidRightBase" );
4869	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpconTblGuidRightDerived" );
4870	····}
4871	····[Test]
4872	····public void HasMappingTable()
4873	····{
4874	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
4875	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
4876	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
4877	····}
4878	····[Test]
4879	····public void HasTypeColumn()
4880	····{
4881	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
4882	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
4883	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
4884	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
4885	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
4886	····}
4887	····[Test]
4888	····public void HasTypeCode()
4889	····{
4890	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4891	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4892	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4893	····}
4894	}
4895
4896
4897	[TestFixture]
4898	public class MappingTestCmpDir1OthpconNoTblGuid : NDOTest
4899	{
4900	····PersistenceManager pm;
4901	····NDOMapping mapping;
4902	····Class ownClass;
4903	····Class otherClass;
4904	····Class otherDerivedClass;
4905	····[SetUp]
4906	····public void Setup()
4907	····{
4908	········this.pm = PmFactory.NewPersistenceManager();
4909	········this.mapping = pm.NDOMapping;
4910	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconNoTblGuidLeft" );
4911	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconNoTblGuidRightBase" );
4912	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconNoTblGuidRightDerived" );
4913	····}
4914	····[Test]
4915	····public void HasMappingTable()
4916	····{
4917	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
4918	····}
4919	····[Test]
4920	····public void HasTypeColumn()
4921	····{
4922	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
4923	····}
4924	····[Test]
4925	····public void HasTypeCode()
4926	····{
4927	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4928	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4929	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4930	····}
4931	}
4932
4933
4934	[TestFixture]
4935	public class MappingTestCmpDir1OthpconTblGuid : NDOTest
4936	{
4937	····PersistenceManager pm;
4938	····NDOMapping mapping;
4939	····Class ownClass;
4940	····Class otherClass;
4941	····Class otherDerivedClass;
4942	····[SetUp]
4943	····public void Setup()
4944	····{
4945	········this.pm = PmFactory.NewPersistenceManager();
4946	········this.mapping = pm.NDOMapping;
4947	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconTblGuidLeft" );
4948	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconTblGuidRightBase" );
4949	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconTblGuidRightDerived" );
4950	····}
4951	····[Test]
4952	····public void HasMappingTable()
4953	····{
4954	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
4955	····}
4956	····[Test]
4957	····public void HasTypeColumn()
4958	····{
4959	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
4960	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
4961	····}
4962	····[Test]
4963	····public void HasTypeCode()
4964	····{
4965	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4966	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4967	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4968	····}
4969	}
4970
4971
4972	[TestFixture]
4973	public class MappingTestCmpBi11OthpconNoTblGuid : NDOTest
4974	{
4975	····PersistenceManager pm;
4976	····NDOMapping mapping;
4977	····Class ownClass;
4978	····Class otherClass;
4979	····Class otherDerivedClass;
4980	····[SetUp]
4981	····public void Setup()
4982	····{
4983	········this.pm = PmFactory.NewPersistenceManager();
4984	········this.mapping = pm.NDOMapping;
4985	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconNoTblGuidLeft" );
4986	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconNoTblGuidRightBase" );
4987	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconNoTblGuidRightDerived" );
4988	····}
4989	····[Test]
4990	····public void HasMappingTable()
4991	····{
4992	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
4993	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
4994	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
4995	····}
4996	····[Test]
4997	····public void HasTypeColumn()
4998	····{
4999	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
5000	····}
5001	····[Test]
5002	····public void HasTypeCode()
5003	····{
5004	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5005	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5006	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5007	····}
5008	}
5009
5010
5011	[TestFixture]
5012	public class MappingTestCmpBi11OthpconTblGuid : NDOTest
5013	{
5014	····PersistenceManager pm;
5015	····NDOMapping mapping;
5016	····Class ownClass;
5017	····Class otherClass;
5018	····Class otherDerivedClass;
5019	····[SetUp]
5020	····public void Setup()
5021	····{
5022	········this.pm = PmFactory.NewPersistenceManager();
5023	········this.mapping = pm.NDOMapping;
5024	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconTblGuidLeft" );
5025	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconTblGuidRightBase" );
5026	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconTblGuidRightDerived" );
5027	····}
5028	····[Test]
5029	····public void HasMappingTable()
5030	····{
5031	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
5032	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
5033	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
5034	····}
5035	····[Test]
5036	····public void HasTypeColumn()
5037	····{
5038	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
5039	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
5040	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
5041	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
5042	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
5043	····}
5044	····[Test]
5045	····public void HasTypeCode()
5046	····{
5047	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5048	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5049	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5050	····}
5051	}
5052
5053
5054	[TestFixture]
5055	public class MappingTestCmpDirnOthpconTblGuid : NDOTest
5056	{
5057	····PersistenceManager pm;
5058	····NDOMapping mapping;
5059	····Class ownClass;
5060	····Class otherClass;
5061	····Class otherDerivedClass;
5062	····[SetUp]
5063	····public void Setup()
5064	····{
5065	········this.pm = PmFactory.NewPersistenceManager();
5066	········this.mapping = pm.NDOMapping;
5067	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpconTblGuidLeft" );
5068	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpconTblGuidRightBase" );
5069	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpconTblGuidRightDerived" );
5070	····}
5071	····[Test]
5072	····public void HasMappingTable()
5073	····{
5074	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
5075	····}
5076	····[Test]
5077	····public void HasTypeColumn()
5078	····{
5079	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
5080	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
5081	····}
5082	····[Test]
5083	····public void HasTypeCode()
5084	····{
5085	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5086	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5087	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5088	····}
5089	}
5090
5091
5092	[TestFixture]
5093	public class MappingTestCmpBin1OthpconTblGuid : NDOTest
5094	{
5095	····PersistenceManager pm;
5096	····NDOMapping mapping;
5097	····Class ownClass;
5098	····Class otherClass;
5099	····Class otherDerivedClass;
5100	····[SetUp]
5101	····public void Setup()
5102	····{
5103	········this.pm = PmFactory.NewPersistenceManager();
5104	········this.mapping = pm.NDOMapping;
5105	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpconTblGuidLeft" );
5106	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpconTblGuidRightBase" );
5107	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpconTblGuidRightDerived" );
5108	····}
5109	····[Test]
5110	····public void HasMappingTable()
5111	····{
5112	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
5113	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
5114	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
5115	····}
5116	····[Test]
5117	····public void HasTypeColumn()
5118	····{
5119	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
5120	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
5121	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
5122	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
5123	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
5124	····}
5125	····[Test]
5126	····public void HasTypeCode()
5127	····{
5128	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5129	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5130	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5131	····}
5132	}
5133
5134
5135	[TestFixture]
5136	public class MappingTestCmpBi1nOthpconNoTblGuid : NDOTest
5137	{
5138	····PersistenceManager pm;
5139	····NDOMapping mapping;
5140	····Class ownClass;
5141	····Class otherClass;
5142	····Class otherDerivedClass;
5143	····[SetUp]
5144	····public void Setup()
5145	····{
5146	········this.pm = PmFactory.NewPersistenceManager();
5147	········this.mapping = pm.NDOMapping;
5148	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconNoTblGuidLeft" );
5149	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconNoTblGuidRightBase" );
5150	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconNoTblGuidRightDerived" );
5151	····}
5152	····[Test]
5153	····public void HasMappingTable()
5154	····{
5155	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
5156	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
5157	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
5158	····}
5159	····[Test]
5160	····public void HasTypeColumn()
5161	····{
5162	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
5163	····}
5164	····[Test]
5165	····public void HasTypeCode()
5166	····{
5167	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5168	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5169	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5170	····}
5171	}
5172
5173
5174	[TestFixture]
5175	public class MappingTestCmpBi1nOthpconTblGuid : NDOTest
5176	{
5177	····PersistenceManager pm;
5178	····NDOMapping mapping;
5179	····Class ownClass;
5180	····Class otherClass;
5181	····Class otherDerivedClass;
5182	····[SetUp]
5183	····public void Setup()
5184	····{
5185	········this.pm = PmFactory.NewPersistenceManager();
5186	········this.mapping = pm.NDOMapping;
5187	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconTblGuidLeft" );
5188	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconTblGuidRightBase" );
5189	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconTblGuidRightDerived" );
5190	····}
5191	····[Test]
5192	····public void HasMappingTable()
5193	····{
5194	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
5195	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
5196	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
5197	····}
5198	····[Test]
5199	····public void HasTypeColumn()
5200	····{
5201	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
5202	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
5203	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
5204	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
5205	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
5206	····}
5207	····[Test]
5208	····public void HasTypeCode()
5209	····{
5210	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5211	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5212	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5213	····}
5214	}
5215
5216
5217	[TestFixture]
5218	public class MappingTestCmpBinnOthpconTblGuid : NDOTest
5219	{
5220	····PersistenceManager pm;
5221	····NDOMapping mapping;
5222	····Class ownClass;
5223	····Class otherClass;
5224	····Class otherDerivedClass;
5225	····[SetUp]
5226	····public void Setup()
5227	····{
5228	········this.pm = PmFactory.NewPersistenceManager();
5229	········this.mapping = pm.NDOMapping;
5230	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpconTblGuidLeft" );
5231	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpconTblGuidRightBase" );
5232	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpconTblGuidRightDerived" );
5233	····}
5234	····[Test]
5235	····public void HasMappingTable()
5236	····{
5237	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
5238	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
5239	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
5240	····}
5241	····[Test]
5242	····public void HasTypeColumn()
5243	····{
5244	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
5245	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
5246	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
5247	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
5248	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
5249	····}
5250	····[Test]
5251	····public void HasTypeCode()
5252	····{
5253	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5254	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5255	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5256	····}
5257	}
5258
5259
5260	[TestFixture]
5261	public class MappingTestAgrDir1OwnpconOthpconNoTblGuid : NDOTest
5262	{
5263	····PersistenceManager pm;
5264	····NDOMapping mapping;
5265	····Class ownClass;
5266	····Class otherClass;
5267	····Class ownDerivedClass;
5268	····Class otherDerivedClass;
5269	····[SetUp]
5270	····public void Setup()
5271	····{
5272	········this.pm = PmFactory.NewPersistenceManager();
5273	········this.mapping = pm.NDOMapping;
5274	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconNoTblGuidLeftBase" );
5275	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconNoTblGuidRightBase" );
5276	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconNoTblGuidLeftDerived" );
5277	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconNoTblGuidRightDerived" );
5278	····}
5279	····[Test]
5280	····public void HasMappingTable()
5281	····{
5282	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
5283	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
5284	····}
5285	····[Test]
5286	····public void HasTypeColumn()
5287	····{
5288	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
5289	····}
5290	····[Test]
5291	····public void HasTypeCode()
5292	····{
5293	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5294	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5295	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5296	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5297	····}
5298	}
5299
5300
5301	[TestFixture]
5302	public class MappingTestAgrDir1OwnpconOthpconTblGuid : NDOTest
5303	{
5304	····PersistenceManager pm;
5305	····NDOMapping mapping;
5306	····Class ownClass;
5307	····Class otherClass;
5308	····Class ownDerivedClass;
5309	····Class otherDerivedClass;
5310	····[SetUp]
5311	····public void Setup()
5312	····{
5313	········this.pm = PmFactory.NewPersistenceManager();
5314	········this.mapping = pm.NDOMapping;
5315	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconTblGuidLeftBase" );
5316	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconTblGuidRightBase" );
5317	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconTblGuidLeftDerived" );
5318	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconTblGuidRightDerived" );
5319	····}
5320	····[Test]
5321	····public void HasMappingTable()
5322	····{
5323	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
5324	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
5325	····}
5326	····[Test]
5327	····public void HasTypeColumn()
5328	····{
5329	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
5330	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
5331	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
5332	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
5333	····}
5334	····[Test]
5335	····public void HasTypeCode()
5336	····{
5337	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5338	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5339	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5340	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5341	····}
5342	}
5343
5344
5345	[TestFixture]
5346	public class MappingTestAgrBi11OwnpconOthpconNoTblGuid : NDOTest
5347	{
5348	····PersistenceManager pm;
5349	····NDOMapping mapping;
5350	····Class ownClass;
5351	····Class otherClass;
5352	····Class ownDerivedClass;
5353	····Class otherDerivedClass;
5354	····[SetUp]
5355	····public void Setup()
5356	····{
5357	········this.pm = PmFactory.NewPersistenceManager();
5358	········this.mapping = pm.NDOMapping;
5359	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconNoTblGuidLeftBase" );
5360	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconNoTblGuidRightBase" );
5361	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconNoTblGuidLeftDerived" );
5362	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconNoTblGuidRightDerived" );
5363	····}
5364	····[Test]
5365	····public void HasMappingTable()
5366	····{
5367	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
5368	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
5369	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
5370	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
5371	····}
5372	····[Test]
5373	····public void HasTypeColumn()
5374	····{
5375	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
5376	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #10");
5377	····}
5378	····[Test]
5379	····public void HasTypeCode()
5380	····{
5381	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5382	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5383	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5384	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5385	····}
5386	}
5387
5388
5389	[TestFixture]
5390	public class MappingTestAgrBi11OwnpconOthpconTblGuid : NDOTest
5391	{
5392	····PersistenceManager pm;
5393	····NDOMapping mapping;
5394	····Class ownClass;
5395	····Class otherClass;
5396	····Class ownDerivedClass;
5397	····Class otherDerivedClass;
5398	····[SetUp]
5399	····public void Setup()
5400	····{
5401	········this.pm = PmFactory.NewPersistenceManager();
5402	········this.mapping = pm.NDOMapping;
5403	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconTblGuidLeftBase" );
5404	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconTblGuidRightBase" );
5405	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconTblGuidLeftDerived" );
5406	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconTblGuidRightDerived" );
5407	····}
5408	····[Test]
5409	····public void HasMappingTable()
5410	····{
5411	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
5412	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
5413	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
5414	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
5415	····}
5416	····[Test]
5417	····public void HasTypeColumn()
5418	····{
5419	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
5420	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
5421	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
5422	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
5423	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
5424	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
5425	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
5426	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
5427	····}
5428	····[Test]
5429	····public void HasTypeCode()
5430	····{
5431	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5432	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5433	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5434	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5435	····}
5436	}
5437
5438
5439	[TestFixture]
5440	public class MappingTestAgrDirnOwnpconOthpconTblGuid : NDOTest
5441	{
5442	····PersistenceManager pm;
5443	····NDOMapping mapping;
5444	····Class ownClass;
5445	····Class otherClass;
5446	····Class ownDerivedClass;
5447	····Class otherDerivedClass;
5448	····[SetUp]
5449	····public void Setup()
5450	····{
5451	········this.pm = PmFactory.NewPersistenceManager();
5452	········this.mapping = pm.NDOMapping;
5453	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconOthpconTblGuidLeftBase" );
5454	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconOthpconTblGuidRightBase" );
5455	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconOthpconTblGuidLeftDerived" );
5456	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconOthpconTblGuidRightDerived" );
5457	····}
5458	····[Test]
5459	····public void HasMappingTable()
5460	····{
5461	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
5462	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
5463	····}
5464	····[Test]
5465	····public void HasTypeColumn()
5466	····{
5467	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
5468	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
5469	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
5470	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
5471	····}
5472	····[Test]
5473	····public void HasTypeCode()
5474	····{
5475	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5476	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5477	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5478	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5479	····}
5480	}
5481
5482
5483	[TestFixture]
5484	public class MappingTestAgrBin1OwnpconOthpconTblGuid : NDOTest
5485	{
5486	····PersistenceManager pm;
5487	····NDOMapping mapping;
5488	····Class ownClass;
5489	····Class otherClass;
5490	····Class ownDerivedClass;
5491	····Class otherDerivedClass;
5492	····[SetUp]
5493	····public void Setup()
5494	····{
5495	········this.pm = PmFactory.NewPersistenceManager();
5496	········this.mapping = pm.NDOMapping;
5497	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconOthpconTblGuidLeftBase" );
5498	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconOthpconTblGuidRightBase" );
5499	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconOthpconTblGuidLeftDerived" );
5500	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconOthpconTblGuidRightDerived" );
5501	····}
5502	····[Test]
5503	····public void HasMappingTable()
5504	····{
5505	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
5506	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
5507	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
5508	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
5509	····}
5510	····[Test]
5511	····public void HasTypeColumn()
5512	····{
5513	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
5514	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
5515	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
5516	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
5517	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
5518	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
5519	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
5520	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
5521	····}
5522	····[Test]
5523	····public void HasTypeCode()
5524	····{
5525	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5526	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5527	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5528	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5529	····}
5530	}
5531
5532
5533	[TestFixture]
5534	public class MappingTestAgrBi1nOwnpconOthpconTblGuid : NDOTest
5535	{
5536	····PersistenceManager pm;
5537	····NDOMapping mapping;
5538	····Class ownClass;
5539	····Class otherClass;
5540	····Class ownDerivedClass;
5541	····Class otherDerivedClass;
5542	····[SetUp]
5543	····public void Setup()
5544	····{
5545	········this.pm = PmFactory.NewPersistenceManager();
5546	········this.mapping = pm.NDOMapping;
5547	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconOthpconTblGuidLeftBase" );
5548	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconOthpconTblGuidRightBase" );
5549	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconOthpconTblGuidLeftDerived" );
5550	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconOthpconTblGuidRightDerived" );
5551	····}
5552	····[Test]
5553	····public void HasMappingTable()
5554	····{
5555	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
5556	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
5557	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
5558	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
5559	····}
5560	····[Test]
5561	····public void HasTypeColumn()
5562	····{
5563	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
5564	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
5565	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
5566	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
5567	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
5568	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
5569	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
5570	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
5571	····}
5572	····[Test]
5573	····public void HasTypeCode()
5574	····{
5575	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5576	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5577	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5578	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5579	····}
5580	}
5581
5582
5583	[TestFixture]
5584	public class MappingTestAgrBinnOwnpconOthpconTblGuid : NDOTest
5585	{
5586	····PersistenceManager pm;
5587	····NDOMapping mapping;
5588	····Class ownClass;
5589	····Class otherClass;
5590	····Class ownDerivedClass;
5591	····Class otherDerivedClass;
5592	····[SetUp]
5593	····public void Setup()
5594	····{
5595	········this.pm = PmFactory.NewPersistenceManager();
5596	········this.mapping = pm.NDOMapping;
5597	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconOthpconTblGuidLeftBase" );
5598	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconOthpconTblGuidRightBase" );
5599	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconOthpconTblGuidLeftDerived" );
5600	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconOthpconTblGuidRightDerived" );
5601	····}
5602	····[Test]
5603	····public void HasMappingTable()
5604	····{
5605	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
5606	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
5607	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
5608	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
5609	····}
5610	····[Test]
5611	····public void HasTypeColumn()
5612	····{
5613	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
5614	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
5615	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
5616	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
5617	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
5618	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
5619	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
5620	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
5621	····}
5622	····[Test]
5623	····public void HasTypeCode()
5624	····{
5625	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5626	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5627	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5628	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5629	····}
5630	}
5631
5632
5633	[TestFixture]
5634	public class MappingTestCmpDir1OwnpconOthpconNoTblGuid : NDOTest
5635	{
5636	····PersistenceManager pm;
5637	····NDOMapping mapping;
5638	····Class ownClass;
5639	····Class otherClass;
5640	····Class ownDerivedClass;
5641	····Class otherDerivedClass;
5642	····[SetUp]
5643	····public void Setup()
5644	····{
5645	········this.pm = PmFactory.NewPersistenceManager();
5646	········this.mapping = pm.NDOMapping;
5647	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconNoTblGuidLeftBase" );
5648	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconNoTblGuidRightBase" );
5649	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconNoTblGuidLeftDerived" );
5650	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconNoTblGuidRightDerived" );
5651	····}
5652	····[Test]
5653	····public void HasMappingTable()
5654	····{
5655	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
5656	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
5657	····}
5658	····[Test]
5659	····public void HasTypeColumn()
5660	····{
5661	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
5662	····}
5663	····[Test]
5664	····public void HasTypeCode()
5665	····{
5666	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5667	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5668	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5669	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5670	····}
5671	}
5672
5673
5674	[TestFixture]
5675	public class MappingTestCmpDir1OwnpconOthpconTblGuid : NDOTest
5676	{
5677	····PersistenceManager pm;
5678	····NDOMapping mapping;
5679	····Class ownClass;
5680	····Class otherClass;
5681	····Class ownDerivedClass;
5682	····Class otherDerivedClass;
5683	····[SetUp]
5684	····public void Setup()
5685	····{
5686	········this.pm = PmFactory.NewPersistenceManager();
5687	········this.mapping = pm.NDOMapping;
5688	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconTblGuidLeftBase" );
5689	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconTblGuidRightBase" );
5690	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconTblGuidLeftDerived" );
5691	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconTblGuidRightDerived" );
5692	····}
5693	····[Test]
5694	····public void HasMappingTable()
5695	····{
5696	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
5697	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
5698	····}
5699	····[Test]
5700	····public void HasTypeColumn()
5701	····{
5702	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
5703	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
5704	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
5705	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
5706	····}
5707	····[Test]
5708	····public void HasTypeCode()
5709	····{
5710	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5711	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5712	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5713	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5714	····}
5715	}
5716
5717
5718	[TestFixture]
5719	public class MappingTestCmpBi11OwnpconOthpconNoTblGuid : NDOTest
5720	{
5721	····PersistenceManager pm;
5722	····NDOMapping mapping;
5723	····Class ownClass;
5724	····Class otherClass;
5725	····Class ownDerivedClass;
5726	····Class otherDerivedClass;
5727	····[SetUp]
5728	····public void Setup()
5729	····{
5730	········this.pm = PmFactory.NewPersistenceManager();
5731	········this.mapping = pm.NDOMapping;
5732	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconNoTblGuidLeftBase" );
5733	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconNoTblGuidRightBase" );
5734	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconNoTblGuidLeftDerived" );
5735	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconNoTblGuidRightDerived" );
5736	····}
5737	····[Test]
5738	····public void HasMappingTable()
5739	····{
5740	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
5741	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
5742	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
5743	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
5744	····}
5745	····[Test]
5746	····public void HasTypeColumn()
5747	····{
5748	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
5749	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #10");
5750	····}
5751	····[Test]
5752	····public void HasTypeCode()
5753	····{
5754	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5755	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5756	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5757	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5758	····}
5759	}
5760
5761
5762	[TestFixture]
5763	public class MappingTestCmpBi11OwnpconOthpconTblGuid : NDOTest
5764	{
5765	····PersistenceManager pm;
5766	····NDOMapping mapping;
5767	····Class ownClass;
5768	····Class otherClass;
5769	····Class ownDerivedClass;
5770	····Class otherDerivedClass;
5771	····[SetUp]
5772	····public void Setup()
5773	····{
5774	········this.pm = PmFactory.NewPersistenceManager();
5775	········this.mapping = pm.NDOMapping;
5776	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconTblGuidLeftBase" );
5777	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconTblGuidRightBase" );
5778	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconTblGuidLeftDerived" );
5779	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconTblGuidRightDerived" );
5780	····}
5781	····[Test]
5782	····public void HasMappingTable()
5783	····{
5784	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
5785	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
5786	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
5787	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
5788	····}
5789	····[Test]
5790	····public void HasTypeColumn()
5791	····{
5792	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
5793	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
5794	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
5795	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
5796	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
5797	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
5798	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
5799	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
5800	····}
5801	····[Test]
5802	····public void HasTypeCode()
5803	····{
5804	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5805	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5806	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5807	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5808	····}
5809	}
5810
5811
5812	[TestFixture]
5813	public class MappingTestCmpDirnOwnpconOthpconTblGuid : NDOTest
5814	{
5815	····PersistenceManager pm;
5816	····NDOMapping mapping;
5817	····Class ownClass;
5818	····Class otherClass;
5819	····Class ownDerivedClass;
5820	····Class otherDerivedClass;
5821	····[SetUp]
5822	····public void Setup()
5823	····{
5824	········this.pm = PmFactory.NewPersistenceManager();
5825	········this.mapping = pm.NDOMapping;
5826	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconOthpconTblGuidLeftBase" );
5827	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconOthpconTblGuidRightBase" );
5828	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconOthpconTblGuidLeftDerived" );
5829	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconOthpconTblGuidRightDerived" );
5830	····}
5831	····[Test]
5832	····public void HasMappingTable()
5833	····{
5834	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
5835	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
5836	····}
5837	····[Test]
5838	····public void HasTypeColumn()
5839	····{
5840	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
5841	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
5842	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
5843	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
5844	····}
5845	····[Test]
5846	····public void HasTypeCode()
5847	····{
5848	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5849	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5850	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5851	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5852	····}
5853	}
5854
5855
5856	[TestFixture]
5857	public class MappingTestCmpBin1OwnpconOthpconTblGuid : NDOTest
5858	{
5859	····PersistenceManager pm;
5860	····NDOMapping mapping;
5861	····Class ownClass;
5862	····Class otherClass;
5863	····Class ownDerivedClass;
5864	····Class otherDerivedClass;
5865	····[SetUp]
5866	····public void Setup()
5867	····{
5868	········this.pm = PmFactory.NewPersistenceManager();
5869	········this.mapping = pm.NDOMapping;
5870	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconOthpconTblGuidLeftBase" );
5871	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconOthpconTblGuidRightBase" );
5872	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconOthpconTblGuidLeftDerived" );
5873	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconOthpconTblGuidRightDerived" );
5874	····}
5875	····[Test]
5876	····public void HasMappingTable()
5877	····{
5878	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
5879	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
5880	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
5881	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
5882	····}
5883	····[Test]
5884	····public void HasTypeColumn()
5885	····{
5886	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
5887	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
5888	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
5889	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
5890	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
5891	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
5892	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
5893	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
5894	····}
5895	····[Test]
5896	····public void HasTypeCode()
5897	····{
5898	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5899	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5900	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5901	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5902	····}
5903	}
5904
5905
5906	[TestFixture]
5907	public class MappingTestCmpBi1nOwnpconOthpconTblGuid : NDOTest
5908	{
5909	····PersistenceManager pm;
5910	····NDOMapping mapping;
5911	····Class ownClass;
5912	····Class otherClass;
5913	····Class ownDerivedClass;
5914	····Class otherDerivedClass;
5915	····[SetUp]
5916	····public void Setup()
5917	····{
5918	········this.pm = PmFactory.NewPersistenceManager();
5919	········this.mapping = pm.NDOMapping;
5920	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconOthpconTblGuidLeftBase" );
5921	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconOthpconTblGuidRightBase" );
5922	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconOthpconTblGuidLeftDerived" );
5923	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconOthpconTblGuidRightDerived" );
5924	····}
5925	····[Test]
5926	····public void HasMappingTable()
5927	····{
5928	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
5929	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
5930	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
5931	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
5932	····}
5933	····[Test]
5934	····public void HasTypeColumn()
5935	····{
5936	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
5937	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
5938	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
5939	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
5940	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
5941	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
5942	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
5943	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
5944	····}
5945	····[Test]
5946	····public void HasTypeCode()
5947	····{
5948	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5949	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5950	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5951	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5952	····}
5953	}
5954
5955
5956	[TestFixture]
5957	public class MappingTestCmpBinnOwnpconOthpconTblGuid : NDOTest
5958	{
5959	····PersistenceManager pm;
5960	····NDOMapping mapping;
5961	····Class ownClass;
5962	····Class otherClass;
5963	····Class ownDerivedClass;
5964	····Class otherDerivedClass;
5965	····[SetUp]
5966	····public void Setup()
5967	····{
5968	········this.pm = PmFactory.NewPersistenceManager();
5969	········this.mapping = pm.NDOMapping;
5970	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconOthpconTblGuidLeftBase" );
5971	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconOthpconTblGuidRightBase" );
5972	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconOthpconTblGuidLeftDerived" );
5973	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconOthpconTblGuidRightDerived" );
5974	····}
5975	····[Test]
5976	····public void HasMappingTable()
5977	····{
5978	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
5979	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
5980	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
5981	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
5982	····}
5983	····[Test]
5984	····public void HasTypeColumn()
5985	····{
5986	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
5987	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
5988	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
5989	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
5990	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
5991	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
5992	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
5993	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
5994	····}
5995	····[Test]
5996	····public void HasTypeCode()
5997	····{
5998	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5999	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6000	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6001	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
6002	····}
6003	}
6004
6005
6006	[TestFixture]
6007	public class MappingTestAgrDir1OwnpabsNoTblAuto : NDOTest
6008	{
6009	····PersistenceManager pm;
6010	····NDOMapping mapping;
6011	····Class ownClass;
6012	····Class otherClass;
6013	····Class ownDerivedClass;
6014	····[SetUp]
6015	····public void Setup()
6016	····{
6017	········this.pm = PmFactory.NewPersistenceManager();
6018	········this.mapping = pm.NDOMapping;
6019	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsNoTblAutoLeftBase" );
6020	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsNoTblAutoRight" );
6021	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsNoTblAutoLeftDerived" );
6022	····}
6023	····[Test]
6024	····public void HasMappingTable()
6025	····{
6026	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
6027	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
6028	····}
6029	····[Test]
6030	····public void HasTypeColumn()
6031	····{
6032	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
6033	····}
6034	····[Test]
6035	····public void HasTypeCode()
6036	····{
6037	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6038	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6039	····}
6040	}
6041
6042
6043	[TestFixture]
6044	public class MappingTestAgrDir1OwnpabsTblAuto : NDOTest
6045	{
6046	····PersistenceManager pm;
6047	····NDOMapping mapping;
6048	····Class ownClass;
6049	····Class otherClass;
6050	····Class ownDerivedClass;
6051	····[SetUp]
6052	····public void Setup()
6053	····{
6054	········this.pm = PmFactory.NewPersistenceManager();
6055	········this.mapping = pm.NDOMapping;
6056	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsTblAutoLeftBase" );
6057	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsTblAutoRight" );
6058	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsTblAutoLeftDerived" );
6059	····}
6060	····[Test]
6061	····public void HasMappingTable()
6062	····{
6063	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
6064	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
6065	····}
6066	····[Test]
6067	····public void HasTypeColumn()
6068	····{
6069	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
6070	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
6071	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
6072	····}
6073	····[Test]
6074	····public void HasTypeCode()
6075	····{
6076	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6077	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6078	····}
6079	}
6080
6081
6082	[TestFixture]
6083	public class MappingTestAgrBi11OwnpabsNoTblAuto : NDOTest
6084	{
6085	····PersistenceManager pm;
6086	····NDOMapping mapping;
6087	····Class ownClass;
6088	····Class otherClass;
6089	····Class ownDerivedClass;
6090	····[SetUp]
6091	····public void Setup()
6092	····{
6093	········this.pm = PmFactory.NewPersistenceManager();
6094	········this.mapping = pm.NDOMapping;
6095	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsNoTblAutoLeftBase" );
6096	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsNoTblAutoRight" );
6097	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsNoTblAutoLeftDerived" );
6098	····}
6099	····[Test]
6100	····public void HasMappingTable()
6101	····{
6102	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
6103	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
6104	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
6105	····}
6106	····[Test]
6107	····public void HasTypeColumn()
6108	····{
6109	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
6110	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #10");
6111	····}
6112	····[Test]
6113	····public void HasTypeCode()
6114	····{
6115	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6116	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6117	····}
6118	}
6119
6120
6121	[TestFixture]
6122	public class MappingTestAgrBi11OwnpabsTblAuto : NDOTest
6123	{
6124	····PersistenceManager pm;
6125	····NDOMapping mapping;
6126	····Class ownClass;
6127	····Class otherClass;
6128	····Class ownDerivedClass;
6129	····[SetUp]
6130	····public void Setup()
6131	····{
6132	········this.pm = PmFactory.NewPersistenceManager();
6133	········this.mapping = pm.NDOMapping;
6134	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsTblAutoLeftBase" );
6135	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsTblAutoRight" );
6136	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsTblAutoLeftDerived" );
6137	····}
6138	····[Test]
6139	····public void HasMappingTable()
6140	····{
6141	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
6142	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
6143	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
6144	····}
6145	····[Test]
6146	····public void HasTypeColumn()
6147	····{
6148	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
6149	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
6150	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
6151	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
6152	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
6153	····}
6154	····[Test]
6155	····public void HasTypeCode()
6156	····{
6157	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6158	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6159	····}
6160	}
6161
6162
6163	[TestFixture]
6164	public class MappingTestAgrDirnOwnpabsNoTblAuto : NDOTest
6165	{
6166	····PersistenceManager pm;
6167	····NDOMapping mapping;
6168	····Class ownClass;
6169	····Class otherClass;
6170	····Class ownDerivedClass;
6171	····[SetUp]
6172	····public void Setup()
6173	····{
6174	········this.pm = PmFactory.NewPersistenceManager();
6175	········this.mapping = pm.NDOMapping;
6176	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsNoTblAutoLeftBase" );
6177	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsNoTblAutoRight" );
6178	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsNoTblAutoLeftDerived" );
6179	····}
6180	····[Test]
6181	····public void HasMappingTable()
6182	····{
6183	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
6184	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
6185	····}
6186	····[Test]
6187	····public void HasTypeColumn()
6188	····{
6189	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
6190	····}
6191	····[Test]
6192	····public void HasTypeCode()
6193	····{
6194	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6195	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6196	····}
6197	}
6198
6199
6200	[TestFixture]
6201	public class MappingTestAgrDirnOwnpabsTblAuto : NDOTest
6202	{
6203	····PersistenceManager pm;
6204	····NDOMapping mapping;
6205	····Class ownClass;
6206	····Class otherClass;
6207	····Class ownDerivedClass;
6208	····[SetUp]
6209	····public void Setup()
6210	····{
6211	········this.pm = PmFactory.NewPersistenceManager();
6212	········this.mapping = pm.NDOMapping;
6213	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsTblAutoLeftBase" );
6214	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsTblAutoRight" );
6215	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsTblAutoLeftDerived" );
6216	····}
6217	····[Test]
6218	····public void HasMappingTable()
6219	····{
6220	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
6221	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
6222	····}
6223	····[Test]
6224	····public void HasTypeColumn()
6225	····{
6226	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
6227	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
6228	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
6229	····}
6230	····[Test]
6231	····public void HasTypeCode()
6232	····{
6233	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6234	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6235	····}
6236	}
6237
6238
6239	[TestFixture]
6240	public class MappingTestAgrBin1OwnpabsNoTblAuto : NDOTest
6241	{
6242	····PersistenceManager pm;
6243	····NDOMapping mapping;
6244	····Class ownClass;
6245	····Class otherClass;
6246	····Class ownDerivedClass;
6247	····[SetUp]
6248	····public void Setup()
6249	····{
6250	········this.pm = PmFactory.NewPersistenceManager();
6251	········this.mapping = pm.NDOMapping;
6252	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsNoTblAutoLeftBase" );
6253	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsNoTblAutoRight" );
6254	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsNoTblAutoLeftDerived" );
6255	····}
6256	····[Test]
6257	····public void HasMappingTable()
6258	····{
6259	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
6260	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
6261	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
6262	····}
6263	····[Test]
6264	····public void HasTypeColumn()
6265	····{
6266	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
6267	····}
6268	····[Test]
6269	····public void HasTypeCode()
6270	····{
6271	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6272	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6273	····}
6274	}
6275
6276
6277	[TestFixture]
6278	public class MappingTestAgrBin1OwnpabsTblAuto : NDOTest
6279	{
6280	····PersistenceManager pm;
6281	····NDOMapping mapping;
6282	····Class ownClass;
6283	····Class otherClass;
6284	····Class ownDerivedClass;
6285	····[SetUp]
6286	····public void Setup()
6287	····{
6288	········this.pm = PmFactory.NewPersistenceManager();
6289	········this.mapping = pm.NDOMapping;
6290	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsTblAutoLeftBase" );
6291	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsTblAutoRight" );
6292	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsTblAutoLeftDerived" );
6293	····}
6294	····[Test]
6295	····public void HasMappingTable()
6296	····{
6297	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
6298	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
6299	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
6300	····}
6301	····[Test]
6302	····public void HasTypeColumn()
6303	····{
6304	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
6305	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
6306	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
6307	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
6308	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
6309	····}
6310	····[Test]
6311	····public void HasTypeCode()
6312	····{
6313	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6314	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6315	····}
6316	}
6317
6318
6319	[TestFixture]
6320	public class MappingTestAgrBi1nOwnpabsTblAuto : NDOTest
6321	{
6322	····PersistenceManager pm;
6323	····NDOMapping mapping;
6324	····Class ownClass;
6325	····Class otherClass;
6326	····Class ownDerivedClass;
6327	····[SetUp]
6328	····public void Setup()
6329	····{
6330	········this.pm = PmFactory.NewPersistenceManager();
6331	········this.mapping = pm.NDOMapping;
6332	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsTblAutoLeftBase" );
6333	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsTblAutoRight" );
6334	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsTblAutoLeftDerived" );
6335	····}
6336	····[Test]
6337	····public void HasMappingTable()
6338	····{
6339	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
6340	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
6341	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
6342	····}
6343	····[Test]
6344	····public void HasTypeColumn()
6345	····{
6346	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
6347	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
6348	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
6349	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
6350	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
6351	····}
6352	····[Test]
6353	····public void HasTypeCode()
6354	····{
6355	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6356	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6357	····}
6358	}
6359
6360
6361	[TestFixture]
6362	public class MappingTestAgrBinnOwnpabsTblAuto : NDOTest
6363	{
6364	····PersistenceManager pm;
6365	····NDOMapping mapping;
6366	····Class ownClass;
6367	····Class otherClass;
6368	····Class ownDerivedClass;
6369	····[SetUp]
6370	····public void Setup()
6371	····{
6372	········this.pm = PmFactory.NewPersistenceManager();
6373	········this.mapping = pm.NDOMapping;
6374	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsTblAutoLeftBase" );
6375	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsTblAutoRight" );
6376	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsTblAutoLeftDerived" );
6377	····}
6378	····[Test]
6379	····public void HasMappingTable()
6380	····{
6381	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
6382	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
6383	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
6384	····}
6385	····[Test]
6386	····public void HasTypeColumn()
6387	····{
6388	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
6389	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
6390	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
6391	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
6392	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
6393	····}
6394	····[Test]
6395	····public void HasTypeCode()
6396	····{
6397	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6398	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6399	····}
6400	}
6401
6402
6403	[TestFixture]
6404	public class MappingTestCmpDir1OwnpabsNoTblAuto : NDOTest
6405	{
6406	····PersistenceManager pm;
6407	····NDOMapping mapping;
6408	····Class ownClass;
6409	····Class otherClass;
6410	····Class ownDerivedClass;
6411	····[SetUp]
6412	····public void Setup()
6413	····{
6414	········this.pm = PmFactory.NewPersistenceManager();
6415	········this.mapping = pm.NDOMapping;
6416	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsNoTblAutoLeftBase" );
6417	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsNoTblAutoRight" );
6418	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsNoTblAutoLeftDerived" );
6419	····}
6420	····[Test]
6421	····public void HasMappingTable()
6422	····{
6423	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
6424	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
6425	····}
6426	····[Test]
6427	····public void HasTypeColumn()
6428	····{
6429	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
6430	····}
6431	····[Test]
6432	····public void HasTypeCode()
6433	····{
6434	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6435	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6436	····}
6437	}
6438
6439
6440	[TestFixture]
6441	public class MappingTestCmpDir1OwnpabsTblAuto : NDOTest
6442	{
6443	····PersistenceManager pm;
6444	····NDOMapping mapping;
6445	····Class ownClass;
6446	····Class otherClass;
6447	····Class ownDerivedClass;
6448	····[SetUp]
6449	····public void Setup()
6450	····{
6451	········this.pm = PmFactory.NewPersistenceManager();
6452	········this.mapping = pm.NDOMapping;
6453	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsTblAutoLeftBase" );
6454	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsTblAutoRight" );
6455	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsTblAutoLeftDerived" );
6456	····}
6457	····[Test]
6458	····public void HasMappingTable()
6459	····{
6460	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
6461	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
6462	····}
6463	····[Test]
6464	····public void HasTypeColumn()
6465	····{
6466	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
6467	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
6468	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
6469	····}
6470	····[Test]
6471	····public void HasTypeCode()
6472	····{
6473	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6474	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6475	····}
6476	}
6477
6478
6479	[TestFixture]
6480	public class MappingTestCmpBi11OwnpabsNoTblAuto : NDOTest
6481	{
6482	····PersistenceManager pm;
6483	····NDOMapping mapping;
6484	····Class ownClass;
6485	····Class otherClass;
6486	····Class ownDerivedClass;
6487	····[SetUp]
6488	····public void Setup()
6489	····{
6490	········this.pm = PmFactory.NewPersistenceManager();
6491	········this.mapping = pm.NDOMapping;
6492	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsNoTblAutoLeftBase" );
6493	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsNoTblAutoRight" );
6494	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsNoTblAutoLeftDerived" );
6495	····}
6496	····[Test]
6497	····public void HasMappingTable()
6498	····{
6499	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
6500	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
6501	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
6502	····}
6503	····[Test]
6504	····public void HasTypeColumn()
6505	····{
6506	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
6507	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #10");
6508	····}
6509	····[Test]
6510	····public void HasTypeCode()
6511	····{
6512	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6513	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6514	····}
6515	}
6516
6517
6518	[TestFixture]
6519	public class MappingTestCmpBi11OwnpabsTblAuto : NDOTest
6520	{
6521	····PersistenceManager pm;
6522	····NDOMapping mapping;
6523	····Class ownClass;
6524	····Class otherClass;
6525	····Class ownDerivedClass;
6526	····[SetUp]
6527	····public void Setup()
6528	····{
6529	········this.pm = PmFactory.NewPersistenceManager();
6530	········this.mapping = pm.NDOMapping;
6531	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsTblAutoLeftBase" );
6532	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsTblAutoRight" );
6533	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsTblAutoLeftDerived" );
6534	····}
6535	····[Test]
6536	····public void HasMappingTable()
6537	····{
6538	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
6539	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
6540	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
6541	····}
6542	····[Test]
6543	····public void HasTypeColumn()
6544	····{
6545	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
6546	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
6547	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
6548	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
6549	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
6550	····}
6551	····[Test]
6552	····public void HasTypeCode()
6553	····{
6554	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6555	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6556	····}
6557	}
6558
6559
6560	[TestFixture]
6561	public class MappingTestCmpDirnOwnpabsNoTblAuto : NDOTest
6562	{
6563	····PersistenceManager pm;
6564	····NDOMapping mapping;
6565	····Class ownClass;
6566	····Class otherClass;
6567	····Class ownDerivedClass;
6568	····[SetUp]
6569	····public void Setup()
6570	····{
6571	········this.pm = PmFactory.NewPersistenceManager();
6572	········this.mapping = pm.NDOMapping;
6573	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsNoTblAutoLeftBase" );
6574	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsNoTblAutoRight" );
6575	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsNoTblAutoLeftDerived" );
6576	····}
6577	····[Test]
6578	····public void HasMappingTable()
6579	····{
6580	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
6581	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
6582	····}
6583	····[Test]
6584	····public void HasTypeColumn()
6585	····{
6586	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
6587	····}
6588	····[Test]
6589	····public void HasTypeCode()
6590	····{
6591	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6592	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6593	····}
6594	}
6595
6596
6597	[TestFixture]
6598	public class MappingTestCmpDirnOwnpabsTblAuto : NDOTest
6599	{
6600	····PersistenceManager pm;
6601	····NDOMapping mapping;
6602	····Class ownClass;
6603	····Class otherClass;
6604	····Class ownDerivedClass;
6605	····[SetUp]
6606	····public void Setup()
6607	····{
6608	········this.pm = PmFactory.NewPersistenceManager();
6609	········this.mapping = pm.NDOMapping;
6610	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsTblAutoLeftBase" );
6611	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsTblAutoRight" );
6612	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsTblAutoLeftDerived" );
6613	····}
6614	····[Test]
6615	····public void HasMappingTable()
6616	····{
6617	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
6618	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
6619	····}
6620	····[Test]
6621	····public void HasTypeColumn()
6622	····{
6623	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
6624	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
6625	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
6626	····}
6627	····[Test]
6628	····public void HasTypeCode()
6629	····{
6630	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6631	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6632	····}
6633	}
6634
6635
6636	[TestFixture]
6637	public class MappingTestCmpBin1OwnpabsNoTblAuto : NDOTest
6638	{
6639	····PersistenceManager pm;
6640	····NDOMapping mapping;
6641	····Class ownClass;
6642	····Class otherClass;
6643	····Class ownDerivedClass;
6644	····[SetUp]
6645	····public void Setup()
6646	····{
6647	········this.pm = PmFactory.NewPersistenceManager();
6648	········this.mapping = pm.NDOMapping;
6649	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsNoTblAutoLeftBase" );
6650	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsNoTblAutoRight" );
6651	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsNoTblAutoLeftDerived" );
6652	····}
6653	····[Test]
6654	····public void HasMappingTable()
6655	····{
6656	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
6657	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
6658	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
6659	····}
6660	····[Test]
6661	····public void HasTypeColumn()
6662	····{
6663	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
6664	····}
6665	····[Test]
6666	····public void HasTypeCode()
6667	····{
6668	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6669	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6670	····}
6671	}
6672
6673
6674	[TestFixture]
6675	public class MappingTestCmpBin1OwnpabsTblAuto : NDOTest
6676	{
6677	····PersistenceManager pm;
6678	····NDOMapping mapping;
6679	····Class ownClass;
6680	····Class otherClass;
6681	····Class ownDerivedClass;
6682	····[SetUp]
6683	····public void Setup()
6684	····{
6685	········this.pm = PmFactory.NewPersistenceManager();
6686	········this.mapping = pm.NDOMapping;
6687	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsTblAutoLeftBase" );
6688	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsTblAutoRight" );
6689	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsTblAutoLeftDerived" );
6690	····}
6691	····[Test]
6692	····public void HasMappingTable()
6693	····{
6694	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
6695	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
6696	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
6697	····}
6698	····[Test]
6699	····public void HasTypeColumn()
6700	····{
6701	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
6702	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
6703	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
6704	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
6705	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
6706	····}
6707	····[Test]
6708	····public void HasTypeCode()
6709	····{
6710	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6711	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6712	····}
6713	}
6714
6715
6716	[TestFixture]
6717	public class MappingTestCmpBi1nOwnpabsTblAuto : NDOTest
6718	{
6719	····PersistenceManager pm;
6720	····NDOMapping mapping;
6721	····Class ownClass;
6722	····Class otherClass;
6723	····Class ownDerivedClass;
6724	····[SetUp]
6725	····public void Setup()
6726	····{
6727	········this.pm = PmFactory.NewPersistenceManager();
6728	········this.mapping = pm.NDOMapping;
6729	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsTblAutoLeftBase" );
6730	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsTblAutoRight" );
6731	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsTblAutoLeftDerived" );
6732	····}
6733	····[Test]
6734	····public void HasMappingTable()
6735	····{
6736	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
6737	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
6738	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
6739	····}
6740	····[Test]
6741	····public void HasTypeColumn()
6742	····{
6743	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
6744	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
6745	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
6746	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
6747	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
6748	····}
6749	····[Test]
6750	····public void HasTypeCode()
6751	····{
6752	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6753	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6754	····}
6755	}
6756
6757
6758	[TestFixture]
6759	public class MappingTestCmpBinnOwnpabsTblAuto : NDOTest
6760	{
6761	····PersistenceManager pm;
6762	····NDOMapping mapping;
6763	····Class ownClass;
6764	····Class otherClass;
6765	····Class ownDerivedClass;
6766	····[SetUp]
6767	····public void Setup()
6768	····{
6769	········this.pm = PmFactory.NewPersistenceManager();
6770	········this.mapping = pm.NDOMapping;
6771	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsTblAutoLeftBase" );
6772	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsTblAutoRight" );
6773	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsTblAutoLeftDerived" );
6774	····}
6775	····[Test]
6776	····public void HasMappingTable()
6777	····{
6778	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
6779	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
6780	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
6781	····}
6782	····[Test]
6783	····public void HasTypeColumn()
6784	····{
6785	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
6786	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
6787	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
6788	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
6789	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
6790	····}
6791	····[Test]
6792	····public void HasTypeCode()
6793	····{
6794	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6795	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6796	····}
6797	}
6798
6799
6800	[TestFixture]
6801	public class MappingTestAgrDir1OthpabsNoTblAuto : NDOTest
6802	{
6803	····PersistenceManager pm;
6804	····NDOMapping mapping;
6805	····Class ownClass;
6806	····Class otherClass;
6807	····Class otherDerivedClass;
6808	····[SetUp]
6809	····public void Setup()
6810	····{
6811	········this.pm = PmFactory.NewPersistenceManager();
6812	········this.mapping = pm.NDOMapping;
6813	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsNoTblAutoLeft" );
6814	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsNoTblAutoRightBase" );
6815	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsNoTblAutoRightDerived" );
6816	····}
6817	····[Test]
6818	····public void HasMappingTable()
6819	····{
6820	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
6821	····}
6822	····[Test]
6823	····public void HasTypeColumn()
6824	····{
6825	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
6826	····}
6827	····[Test]
6828	····public void HasTypeCode()
6829	····{
6830	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
6831	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
6832	····}
6833	}
6834
6835
6836	[TestFixture]
6837	public class MappingTestAgrDir1OthpabsTblAuto : NDOTest
6838	{
6839	····PersistenceManager pm;
6840	····NDOMapping mapping;
6841	····Class ownClass;
6842	····Class otherClass;
6843	····Class otherDerivedClass;
6844	····[SetUp]
6845	····public void Setup()
6846	····{
6847	········this.pm = PmFactory.NewPersistenceManager();
6848	········this.mapping = pm.NDOMapping;
6849	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsTblAutoLeft" );
6850	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsTblAutoRightBase" );
6851	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsTblAutoRightDerived" );
6852	····}
6853	····[Test]
6854	····public void HasMappingTable()
6855	····{
6856	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
6857	····}
6858	····[Test]
6859	····public void HasTypeColumn()
6860	····{
6861	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
6862	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
6863	····}
6864	····[Test]
6865	····public void HasTypeCode()
6866	····{
6867	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
6868	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
6869	····}
6870	}
6871
6872
6873	[TestFixture]
6874	public class MappingTestAgrBi11OthpabsNoTblAuto : NDOTest
6875	{
6876	····PersistenceManager pm;
6877	····NDOMapping mapping;
6878	····Class ownClass;
6879	····Class otherClass;
6880	····Class otherDerivedClass;
6881	····[SetUp]
6882	····public void Setup()
6883	····{
6884	········this.pm = PmFactory.NewPersistenceManager();
6885	········this.mapping = pm.NDOMapping;
6886	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsNoTblAutoLeft" );
6887	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsNoTblAutoRightBase" );
6888	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsNoTblAutoRightDerived" );
6889	····}
6890	····[Test]
6891	····public void HasMappingTable()
6892	····{
6893	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
6894	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
6895	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
6896	····}
6897	····[Test]
6898	····public void HasTypeColumn()
6899	····{
6900	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
6901	····}
6902	····[Test]
6903	····public void HasTypeCode()
6904	····{
6905	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
6906	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
6907	····}
6908	}
6909
6910
6911	[TestFixture]
6912	public class MappingTestAgrBi11OthpabsTblAuto : NDOTest
6913	{
6914	····PersistenceManager pm;
6915	····NDOMapping mapping;
6916	····Class ownClass;
6917	····Class otherClass;
6918	····Class otherDerivedClass;
6919	····[SetUp]
6920	····public void Setup()
6921	····{
6922	········this.pm = PmFactory.NewPersistenceManager();
6923	········this.mapping = pm.NDOMapping;
6924	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsTblAutoLeft" );
6925	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsTblAutoRightBase" );
6926	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsTblAutoRightDerived" );
6927	····}
6928	····[Test]
6929	····public void HasMappingTable()
6930	····{
6931	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
6932	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
6933	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
6934	····}
6935	····[Test]
6936	····public void HasTypeColumn()
6937	····{
6938	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
6939	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
6940	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
6941	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
6942	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
6943	····}
6944	····[Test]
6945	····public void HasTypeCode()
6946	····{
6947	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
6948	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
6949	····}
6950	}
6951
6952
6953	[TestFixture]
6954	public class MappingTestAgrDirnOthpabsTblAuto : NDOTest
6955	{
6956	····PersistenceManager pm;
6957	····NDOMapping mapping;
6958	····Class ownClass;
6959	····Class otherClass;
6960	····Class otherDerivedClass;
6961	····[SetUp]
6962	····public void Setup()
6963	····{
6964	········this.pm = PmFactory.NewPersistenceManager();
6965	········this.mapping = pm.NDOMapping;
6966	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpabsTblAutoLeft" );
6967	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpabsTblAutoRightBase" );
6968	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpabsTblAutoRightDerived" );
6969	····}
6970	····[Test]
6971	····public void HasMappingTable()
6972	····{
6973	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
6974	····}
6975	····[Test]
6976	····public void HasTypeColumn()
6977	····{
6978	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
6979	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
6980	····}
6981	····[Test]
6982	····public void HasTypeCode()
6983	····{
6984	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
6985	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
6986	····}
6987	}
6988
6989
6990	[TestFixture]
6991	public class MappingTestAgrBin1OthpabsTblAuto : NDOTest
6992	{
6993	····PersistenceManager pm;
6994	····NDOMapping mapping;
6995	····Class ownClass;
6996	····Class otherClass;
6997	····Class otherDerivedClass;
6998	····[SetUp]
6999	····public void Setup()
7000	····{
7001	········this.pm = PmFactory.NewPersistenceManager();
7002	········this.mapping = pm.NDOMapping;
7003	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpabsTblAutoLeft" );
7004	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpabsTblAutoRightBase" );
7005	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpabsTblAutoRightDerived" );
7006	····}
7007	····[Test]
7008	····public void HasMappingTable()
7009	····{
7010	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7011	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
7012	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
7013	····}
7014	····[Test]
7015	····public void HasTypeColumn()
7016	····{
7017	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7018	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
7019	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
7020	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
7021	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
7022	····}
7023	····[Test]
7024	····public void HasTypeCode()
7025	····{
7026	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7027	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7028	····}
7029	}
7030
7031
7032	[TestFixture]
7033	public class MappingTestAgrBi1nOthpabsNoTblAuto : NDOTest
7034	{
7035	····PersistenceManager pm;
7036	····NDOMapping mapping;
7037	····Class ownClass;
7038	····Class otherClass;
7039	····Class otherDerivedClass;
7040	····[SetUp]
7041	····public void Setup()
7042	····{
7043	········this.pm = PmFactory.NewPersistenceManager();
7044	········this.mapping = pm.NDOMapping;
7045	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsNoTblAutoLeft" );
7046	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsNoTblAutoRightBase" );
7047	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsNoTblAutoRightDerived" );
7048	····}
7049	····[Test]
7050	····public void HasMappingTable()
7051	····{
7052	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
7053	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
7054	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
7055	····}
7056	····[Test]
7057	····public void HasTypeColumn()
7058	····{
7059	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
7060	····}
7061	····[Test]
7062	····public void HasTypeCode()
7063	····{
7064	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7065	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7066	····}
7067	}
7068
7069
7070	[TestFixture]
7071	public class MappingTestAgrBi1nOthpabsTblAuto : NDOTest
7072	{
7073	····PersistenceManager pm;
7074	····NDOMapping mapping;
7075	····Class ownClass;
7076	····Class otherClass;
7077	····Class otherDerivedClass;
7078	····[SetUp]
7079	····public void Setup()
7080	····{
7081	········this.pm = PmFactory.NewPersistenceManager();
7082	········this.mapping = pm.NDOMapping;
7083	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsTblAutoLeft" );
7084	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsTblAutoRightBase" );
7085	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsTblAutoRightDerived" );
7086	····}
7087	····[Test]
7088	····public void HasMappingTable()
7089	····{
7090	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7091	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
7092	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
7093	····}
7094	····[Test]
7095	····public void HasTypeColumn()
7096	····{
7097	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7098	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
7099	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
7100	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
7101	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
7102	····}
7103	····[Test]
7104	····public void HasTypeCode()
7105	····{
7106	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7107	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7108	····}
7109	}
7110
7111
7112	[TestFixture]
7113	public class MappingTestAgrBinnOthpabsTblAuto : NDOTest
7114	{
7115	····PersistenceManager pm;
7116	····NDOMapping mapping;
7117	····Class ownClass;
7118	····Class otherClass;
7119	····Class otherDerivedClass;
7120	····[SetUp]
7121	····public void Setup()
7122	····{
7123	········this.pm = PmFactory.NewPersistenceManager();
7124	········this.mapping = pm.NDOMapping;
7125	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpabsTblAutoLeft" );
7126	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpabsTblAutoRightBase" );
7127	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpabsTblAutoRightDerived" );
7128	····}
7129	····[Test]
7130	····public void HasMappingTable()
7131	····{
7132	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7133	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
7134	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
7135	····}
7136	····[Test]
7137	····public void HasTypeColumn()
7138	····{
7139	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7140	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
7141	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
7142	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
7143	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
7144	····}
7145	····[Test]
7146	····public void HasTypeCode()
7147	····{
7148	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7149	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7150	····}
7151	}
7152
7153
7154	[TestFixture]
7155	public class MappingTestCmpDir1OthpabsTblAuto : NDOTest
7156	{
7157	····PersistenceManager pm;
7158	····NDOMapping mapping;
7159	····Class ownClass;
7160	····Class otherClass;
7161	····Class otherDerivedClass;
7162	····[SetUp]
7163	····public void Setup()
7164	····{
7165	········this.pm = PmFactory.NewPersistenceManager();
7166	········this.mapping = pm.NDOMapping;
7167	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsTblAutoLeft" );
7168	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsTblAutoRightBase" );
7169	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsTblAutoRightDerived" );
7170	····}
7171	····[Test]
7172	····public void HasMappingTable()
7173	····{
7174	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7175	····}
7176	····[Test]
7177	····public void HasTypeColumn()
7178	····{
7179	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7180	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
7181	····}
7182	····[Test]
7183	····public void HasTypeCode()
7184	····{
7185	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7186	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7187	····}
7188	}
7189
7190
7191	[TestFixture]
7192	public class MappingTestCmpBi11OthpabsTblAuto : NDOTest
7193	{
7194	····PersistenceManager pm;
7195	····NDOMapping mapping;
7196	····Class ownClass;
7197	····Class otherClass;
7198	····Class otherDerivedClass;
7199	····[SetUp]
7200	····public void Setup()
7201	····{
7202	········this.pm = PmFactory.NewPersistenceManager();
7203	········this.mapping = pm.NDOMapping;
7204	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsTblAutoLeft" );
7205	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsTblAutoRightBase" );
7206	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsTblAutoRightDerived" );
7207	····}
7208	····[Test]
7209	····public void HasMappingTable()
7210	····{
7211	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7212	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
7213	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
7214	····}
7215	····[Test]
7216	····public void HasTypeColumn()
7217	····{
7218	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7219	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
7220	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
7221	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
7222	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
7223	····}
7224	····[Test]
7225	····public void HasTypeCode()
7226	····{
7227	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7228	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7229	····}
7230	}
7231
7232
7233	[TestFixture]
7234	public class MappingTestCmpDirnOthpabsTblAuto : NDOTest
7235	{
7236	····PersistenceManager pm;
7237	····NDOMapping mapping;
7238	····Class ownClass;
7239	····Class otherClass;
7240	····Class otherDerivedClass;
7241	····[SetUp]
7242	····public void Setup()
7243	····{
7244	········this.pm = PmFactory.NewPersistenceManager();
7245	········this.mapping = pm.NDOMapping;
7246	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpabsTblAutoLeft" );
7247	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpabsTblAutoRightBase" );
7248	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpabsTblAutoRightDerived" );
7249	····}
7250	····[Test]
7251	····public void HasMappingTable()
7252	····{
7253	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7254	····}
7255	····[Test]
7256	····public void HasTypeColumn()
7257	····{
7258	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7259	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
7260	····}
7261	····[Test]
7262	····public void HasTypeCode()
7263	····{
7264	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7265	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7266	····}
7267	}
7268
7269
7270	[TestFixture]
7271	public class MappingTestCmpBin1OthpabsTblAuto : NDOTest
7272	{
7273	····PersistenceManager pm;
7274	····NDOMapping mapping;
7275	····Class ownClass;
7276	····Class otherClass;
7277	····Class otherDerivedClass;
7278	····[SetUp]
7279	····public void Setup()
7280	····{
7281	········this.pm = PmFactory.NewPersistenceManager();
7282	········this.mapping = pm.NDOMapping;
7283	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpabsTblAutoLeft" );
7284	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpabsTblAutoRightBase" );
7285	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpabsTblAutoRightDerived" );
7286	····}
7287	····[Test]
7288	····public void HasMappingTable()
7289	····{
7290	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7291	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
7292	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
7293	····}
7294	····[Test]
7295	····public void HasTypeColumn()
7296	····{
7297	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7298	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
7299	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
7300	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
7301	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
7302	····}
7303	····[Test]
7304	····public void HasTypeCode()
7305	····{
7306	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7307	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7308	····}
7309	}
7310
7311
7312	[TestFixture]
7313	public class MappingTestCmpBi1nOthpabsTblAuto : NDOTest
7314	{
7315	····PersistenceManager pm;
7316	····NDOMapping mapping;
7317	····Class ownClass;
7318	····Class otherClass;
7319	····Class otherDerivedClass;
7320	····[SetUp]
7321	····public void Setup()
7322	····{
7323	········this.pm = PmFactory.NewPersistenceManager();
7324	········this.mapping = pm.NDOMapping;
7325	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsTblAutoLeft" );
7326	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsTblAutoRightBase" );
7327	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsTblAutoRightDerived" );
7328	····}
7329	····[Test]
7330	····public void HasMappingTable()
7331	····{
7332	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7333	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
7334	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
7335	····}
7336	····[Test]
7337	····public void HasTypeColumn()
7338	····{
7339	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7340	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
7341	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
7342	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
7343	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
7344	····}
7345	····[Test]
7346	····public void HasTypeCode()
7347	····{
7348	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7349	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7350	····}
7351	}
7352
7353
7354	[TestFixture]
7355	public class MappingTestCmpBinnOthpabsTblAuto : NDOTest
7356	{
7357	····PersistenceManager pm;
7358	····NDOMapping mapping;
7359	····Class ownClass;
7360	····Class otherClass;
7361	····Class otherDerivedClass;
7362	····[SetUp]
7363	····public void Setup()
7364	····{
7365	········this.pm = PmFactory.NewPersistenceManager();
7366	········this.mapping = pm.NDOMapping;
7367	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpabsTblAutoLeft" );
7368	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpabsTblAutoRightBase" );
7369	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpabsTblAutoRightDerived" );
7370	····}
7371	····[Test]
7372	····public void HasMappingTable()
7373	····{
7374	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7375	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
7376	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
7377	····}
7378	····[Test]
7379	····public void HasTypeColumn()
7380	····{
7381	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7382	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
7383	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
7384	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
7385	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
7386	····}
7387	····[Test]
7388	····public void HasTypeCode()
7389	····{
7390	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7391	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7392	····}
7393	}
7394
7395
7396	[TestFixture]
7397	public class MappingTestAgrDir1OwnpabsOthpabsNoTblAuto : NDOTest
7398	{
7399	····PersistenceManager pm;
7400	····NDOMapping mapping;
7401	····Class ownClass;
7402	····Class otherClass;
7403	····Class ownDerivedClass;
7404	····Class otherDerivedClass;
7405	····[SetUp]
7406	····public void Setup()
7407	····{
7408	········this.pm = PmFactory.NewPersistenceManager();
7409	········this.mapping = pm.NDOMapping;
7410	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsNoTblAutoLeftBase" );
7411	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsNoTblAutoRightBase" );
7412	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsNoTblAutoLeftDerived" );
7413	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsNoTblAutoRightDerived" );
7414	····}
7415	····[Test]
7416	····public void HasMappingTable()
7417	····{
7418	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
7419	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
7420	····}
7421	····[Test]
7422	····public void HasTypeColumn()
7423	····{
7424	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
7425	····}
7426	····[Test]
7427	····public void HasTypeCode()
7428	····{
7429	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7430	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7431	····}
7432	}
7433
7434
7435	[TestFixture]
7436	public class MappingTestAgrDir1OwnpabsOthpabsTblAuto : NDOTest
7437	{
7438	····PersistenceManager pm;
7439	····NDOMapping mapping;
7440	····Class ownClass;
7441	····Class otherClass;
7442	····Class ownDerivedClass;
7443	····Class otherDerivedClass;
7444	····[SetUp]
7445	····public void Setup()
7446	····{
7447	········this.pm = PmFactory.NewPersistenceManager();
7448	········this.mapping = pm.NDOMapping;
7449	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsTblAutoLeftBase" );
7450	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsTblAutoRightBase" );
7451	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsTblAutoLeftDerived" );
7452	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsTblAutoRightDerived" );
7453	····}
7454	····[Test]
7455	····public void HasMappingTable()
7456	····{
7457	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7458	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
7459	····}
7460	····[Test]
7461	····public void HasTypeColumn()
7462	····{
7463	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
7464	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
7465	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7466	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
7467	····}
7468	····[Test]
7469	····public void HasTypeCode()
7470	····{
7471	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7472	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7473	····}
7474	}
7475
7476
7477	[TestFixture]
7478	public class MappingTestAgrBi11OwnpabsOthpabsNoTblAuto : NDOTest
7479	{
7480	····PersistenceManager pm;
7481	····NDOMapping mapping;
7482	····Class ownClass;
7483	····Class otherClass;
7484	····Class ownDerivedClass;
7485	····Class otherDerivedClass;
7486	····[SetUp]
7487	····public void Setup()
7488	····{
7489	········this.pm = PmFactory.NewPersistenceManager();
7490	········this.mapping = pm.NDOMapping;
7491	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsNoTblAutoLeftBase" );
7492	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsNoTblAutoRightBase" );
7493	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsNoTblAutoLeftDerived" );
7494	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsNoTblAutoRightDerived" );
7495	····}
7496	····[Test]
7497	····public void HasMappingTable()
7498	····{
7499	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
7500	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
7501	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
7502	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
7503	····}
7504	····[Test]
7505	····public void HasTypeColumn()
7506	····{
7507	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
7508	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #10");
7509	····}
7510	····[Test]
7511	····public void HasTypeCode()
7512	····{
7513	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7514	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7515	····}
7516	}
7517
7518
7519	[TestFixture]
7520	public class MappingTestAgrBi11OwnpabsOthpabsTblAuto : NDOTest
7521	{
7522	····PersistenceManager pm;
7523	····NDOMapping mapping;
7524	····Class ownClass;
7525	····Class otherClass;
7526	····Class ownDerivedClass;
7527	····Class otherDerivedClass;
7528	····[SetUp]
7529	····public void Setup()
7530	····{
7531	········this.pm = PmFactory.NewPersistenceManager();
7532	········this.mapping = pm.NDOMapping;
7533	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsTblAutoLeftBase" );
7534	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsTblAutoRightBase" );
7535	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsTblAutoLeftDerived" );
7536	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsTblAutoRightDerived" );
7537	····}
7538	····[Test]
7539	····public void HasMappingTable()
7540	····{
7541	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7542	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
7543	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
7544	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
7545	····}
7546	····[Test]
7547	····public void HasTypeColumn()
7548	····{
7549	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
7550	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
7551	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7552	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
7553	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
7554	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
7555	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
7556	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
7557	····}
7558	····[Test]
7559	····public void HasTypeCode()
7560	····{
7561	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7562	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7563	····}
7564	}
7565
7566
7567	[TestFixture]
7568	public class MappingTestAgrDirnOwnpabsOthpabsTblAuto : NDOTest
7569	{
7570	····PersistenceManager pm;
7571	····NDOMapping mapping;
7572	····Class ownClass;
7573	····Class otherClass;
7574	····Class ownDerivedClass;
7575	····Class otherDerivedClass;
7576	····[SetUp]
7577	····public void Setup()
7578	····{
7579	········this.pm = PmFactory.NewPersistenceManager();
7580	········this.mapping = pm.NDOMapping;
7581	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsOthpabsTblAutoLeftBase" );
7582	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsOthpabsTblAutoRightBase" );
7583	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsOthpabsTblAutoLeftDerived" );
7584	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsOthpabsTblAutoRightDerived" );
7585	····}
7586	····[Test]
7587	····public void HasMappingTable()
7588	····{
7589	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7590	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
7591	····}
7592	····[Test]
7593	····public void HasTypeColumn()
7594	····{
7595	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
7596	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
7597	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7598	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
7599	····}
7600	····[Test]
7601	····public void HasTypeCode()
7602	····{
7603	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7604	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7605	····}
7606	}
7607
7608
7609	[TestFixture]
7610	public class MappingTestAgrBin1OwnpabsOthpabsTblAuto : NDOTest
7611	{
7612	····PersistenceManager pm;
7613	····NDOMapping mapping;
7614	····Class ownClass;
7615	····Class otherClass;
7616	····Class ownDerivedClass;
7617	····Class otherDerivedClass;
7618	····[SetUp]
7619	····public void Setup()
7620	····{
7621	········this.pm = PmFactory.NewPersistenceManager();
7622	········this.mapping = pm.NDOMapping;
7623	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsOthpabsTblAutoLeftBase" );
7624	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsOthpabsTblAutoRightBase" );
7625	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsOthpabsTblAutoLeftDerived" );
7626	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsOthpabsTblAutoRightDerived" );
7627	····}
7628	····[Test]
7629	····public void HasMappingTable()
7630	····{
7631	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7632	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
7633	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
7634	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
7635	····}
7636	····[Test]
7637	····public void HasTypeColumn()
7638	····{
7639	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
7640	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
7641	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7642	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
7643	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
7644	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
7645	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
7646	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
7647	····}
7648	····[Test]
7649	····public void HasTypeCode()
7650	····{
7651	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7652	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7653	····}
7654	}
7655
7656
7657	[TestFixture]
7658	public class MappingTestAgrBi1nOwnpabsOthpabsTblAuto : NDOTest
7659	{
7660	····PersistenceManager pm;
7661	····NDOMapping mapping;
7662	····Class ownClass;
7663	····Class otherClass;
7664	····Class ownDerivedClass;
7665	····Class otherDerivedClass;
7666	····[SetUp]
7667	····public void Setup()
7668	····{
7669	········this.pm = PmFactory.NewPersistenceManager();
7670	········this.mapping = pm.NDOMapping;
7671	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsOthpabsTblAutoLeftBase" );
7672	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsOthpabsTblAutoRightBase" );
7673	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsOthpabsTblAutoLeftDerived" );
7674	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsOthpabsTblAutoRightDerived" );
7675	····}
7676	····[Test]
7677	····public void HasMappingTable()
7678	····{
7679	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7680	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
7681	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
7682	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
7683	····}
7684	····[Test]
7685	····public void HasTypeColumn()
7686	····{
7687	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
7688	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
7689	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7690	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
7691	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
7692	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
7693	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
7694	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
7695	····}
7696	····[Test]
7697	····public void HasTypeCode()
7698	····{
7699	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7700	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7701	····}
7702	}
7703
7704
7705	[TestFixture]
7706	public class MappingTestAgrBinnOwnpabsOthpabsTblAuto : NDOTest
7707	{
7708	····PersistenceManager pm;
7709	····NDOMapping mapping;
7710	····Class ownClass;
7711	····Class otherClass;
7712	····Class ownDerivedClass;
7713	····Class otherDerivedClass;
7714	····[SetUp]
7715	····public void Setup()
7716	····{
7717	········this.pm = PmFactory.NewPersistenceManager();
7718	········this.mapping = pm.NDOMapping;
7719	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsOthpabsTblAutoLeftBase" );
7720	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsOthpabsTblAutoRightBase" );
7721	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsOthpabsTblAutoLeftDerived" );
7722	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsOthpabsTblAutoRightDerived" );
7723	····}
7724	····[Test]
7725	····public void HasMappingTable()
7726	····{
7727	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7728	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
7729	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
7730	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
7731	····}
7732	····[Test]
7733	····public void HasTypeColumn()
7734	····{
7735	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
7736	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
7737	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7738	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
7739	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
7740	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
7741	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
7742	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
7743	····}
7744	····[Test]
7745	····public void HasTypeCode()
7746	····{
7747	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7748	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7749	····}
7750	}
7751
7752
7753	[TestFixture]
7754	public class MappingTestCmpDir1OwnpabsOthpabsTblAuto : NDOTest
7755	{
7756	····PersistenceManager pm;
7757	····NDOMapping mapping;
7758	····Class ownClass;
7759	····Class otherClass;
7760	····Class ownDerivedClass;
7761	····Class otherDerivedClass;
7762	····[SetUp]
7763	····public void Setup()
7764	····{
7765	········this.pm = PmFactory.NewPersistenceManager();
7766	········this.mapping = pm.NDOMapping;
7767	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsTblAutoLeftBase" );
7768	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsTblAutoRightBase" );
7769	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsTblAutoLeftDerived" );
7770	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsTblAutoRightDerived" );
7771	····}
7772	····[Test]
7773	····public void HasMappingTable()
7774	····{
7775	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7776	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
7777	····}
7778	····[Test]
7779	····public void HasTypeColumn()
7780	····{
7781	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
7782	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
7783	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7784	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
7785	····}
7786	····[Test]
7787	····public void HasTypeCode()
7788	····{
7789	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7790	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7791	····}
7792	}
7793
7794
7795	[TestFixture]
7796	public class MappingTestCmpBi11OwnpabsOthpabsTblAuto : NDOTest
7797	{
7798	····PersistenceManager pm;
7799	····NDOMapping mapping;
7800	····Class ownClass;
7801	····Class otherClass;
7802	····Class ownDerivedClass;
7803	····Class otherDerivedClass;
7804	····[SetUp]
7805	····public void Setup()
7806	····{
7807	········this.pm = PmFactory.NewPersistenceManager();
7808	········this.mapping = pm.NDOMapping;
7809	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsTblAutoLeftBase" );
7810	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsTblAutoRightBase" );
7811	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsTblAutoLeftDerived" );
7812	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsTblAutoRightDerived" );
7813	····}
7814	····[Test]
7815	····public void HasMappingTable()
7816	····{
7817	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7818	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
7819	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
7820	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
7821	····}
7822	····[Test]
7823	····public void HasTypeColumn()
7824	····{
7825	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
7826	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
7827	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7828	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
7829	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
7830	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
7831	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
7832	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
7833	····}
7834	····[Test]
7835	····public void HasTypeCode()
7836	····{
7837	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7838	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7839	····}
7840	}
7841
7842
7843	[TestFixture]
7844	public class MappingTestCmpDirnOwnpabsOthpabsTblAuto : NDOTest
7845	{
7846	····PersistenceManager pm;
7847	····NDOMapping mapping;
7848	····Class ownClass;
7849	····Class otherClass;
7850	····Class ownDerivedClass;
7851	····Class otherDerivedClass;
7852	····[SetUp]
7853	····public void Setup()
7854	····{
7855	········this.pm = PmFactory.NewPersistenceManager();
7856	········this.mapping = pm.NDOMapping;
7857	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsOthpabsTblAutoLeftBase" );
7858	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsOthpabsTblAutoRightBase" );
7859	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsOthpabsTblAutoLeftDerived" );
7860	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsOthpabsTblAutoRightDerived" );
7861	····}
7862	····[Test]
7863	····public void HasMappingTable()
7864	····{
7865	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7866	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
7867	····}
7868	····[Test]
7869	····public void HasTypeColumn()
7870	····{
7871	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
7872	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
7873	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7874	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
7875	····}
7876	····[Test]
7877	····public void HasTypeCode()
7878	····{
7879	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7880	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7881	····}
7882	}
7883
7884
7885	[TestFixture]
7886	public class MappingTestCmpBin1OwnpabsOthpabsTblAuto : NDOTest
7887	{
7888	····PersistenceManager pm;
7889	····NDOMapping mapping;
7890	····Class ownClass;
7891	····Class otherClass;
7892	····Class ownDerivedClass;
7893	····Class otherDerivedClass;
7894	····[SetUp]
7895	····public void Setup()
7896	····{
7897	········this.pm = PmFactory.NewPersistenceManager();
7898	········this.mapping = pm.NDOMapping;
7899	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsOthpabsTblAutoLeftBase" );
7900	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsOthpabsTblAutoRightBase" );
7901	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsOthpabsTblAutoLeftDerived" );
7902	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsOthpabsTblAutoRightDerived" );
7903	····}
7904	····[Test]
7905	····public void HasMappingTable()
7906	····{
7907	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7908	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
7909	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
7910	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
7911	····}
7912	····[Test]
7913	····public void HasTypeColumn()
7914	····{
7915	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
7916	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
7917	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7918	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
7919	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
7920	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
7921	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
7922	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
7923	····}
7924	····[Test]
7925	····public void HasTypeCode()
7926	····{
7927	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7928	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7929	····}
7930	}
7931
7932
7933	[TestFixture]
7934	public class MappingTestCmpBi1nOwnpabsOthpabsTblAuto : NDOTest
7935	{
7936	····PersistenceManager pm;
7937	····NDOMapping mapping;
7938	····Class ownClass;
7939	····Class otherClass;
7940	····Class ownDerivedClass;
7941	····Class otherDerivedClass;
7942	····[SetUp]
7943	····public void Setup()
7944	····{
7945	········this.pm = PmFactory.NewPersistenceManager();
7946	········this.mapping = pm.NDOMapping;
7947	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsOthpabsTblAutoLeftBase" );
7948	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsOthpabsTblAutoRightBase" );
7949	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsOthpabsTblAutoLeftDerived" );
7950	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsOthpabsTblAutoRightDerived" );
7951	····}
7952	····[Test]
7953	····public void HasMappingTable()
7954	····{
7955	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
7956	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
7957	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
7958	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
7959	····}
7960	····[Test]
7961	····public void HasTypeColumn()
7962	····{
7963	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
7964	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
7965	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
7966	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
7967	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
7968	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
7969	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
7970	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
7971	····}
7972	····[Test]
7973	····public void HasTypeCode()
7974	····{
7975	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7976	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7977	····}
7978	}
7979
7980
7981	[TestFixture]
7982	public class MappingTestCmpBinnOwnpabsOthpabsTblAuto : NDOTest
7983	{
7984	····PersistenceManager pm;
7985	····NDOMapping mapping;
7986	····Class ownClass;
7987	····Class otherClass;
7988	····Class ownDerivedClass;
7989	····Class otherDerivedClass;
7990	····[SetUp]
7991	····public void Setup()
7992	····{
7993	········this.pm = PmFactory.NewPersistenceManager();
7994	········this.mapping = pm.NDOMapping;
7995	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsOthpabsTblAutoLeftBase" );
7996	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsOthpabsTblAutoRightBase" );
7997	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsOthpabsTblAutoLeftDerived" );
7998	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsOthpabsTblAutoRightDerived" );
7999	····}
8000	····[Test]
8001	····public void HasMappingTable()
8002	····{
8003	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
8004	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
8005	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
8006	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
8007	····}
8008	····[Test]
8009	····public void HasTypeColumn()
8010	····{
8011	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
8012	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
8013	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
8014	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
8015	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
8016	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
8017	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
8018	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
8019	····}
8020	····[Test]
8021	····public void HasTypeCode()
8022	····{
8023	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8024	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
8025	····}
8026	}
8027
8028
8029	[TestFixture]
8030	public class MappingTestAgrDir1OwnpabsNoTblGuid : NDOTest
8031	{
8032	····PersistenceManager pm;
8033	····NDOMapping mapping;
8034	····Class ownClass;
8035	····Class otherClass;
8036	····Class ownDerivedClass;
8037	····[SetUp]
8038	····public void Setup()
8039	····{
8040	········this.pm = PmFactory.NewPersistenceManager();
8041	········this.mapping = pm.NDOMapping;
8042	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsNoTblGuidLeftBase" );
8043	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsNoTblGuidRight" );
8044	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsNoTblGuidLeftDerived" );
8045	····}
8046	····[Test]
8047	····public void HasMappingTable()
8048	····{
8049	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
8050	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
8051	····}
8052	····[Test]
8053	····public void HasTypeColumn()
8054	····{
8055	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
8056	····}
8057	····[Test]
8058	····public void HasTypeCode()
8059	····{
8060	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8061	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8062	····}
8063	}
8064
8065
8066	[TestFixture]
8067	public class MappingTestAgrDir1OwnpabsTblGuid : NDOTest
8068	{
8069	····PersistenceManager pm;
8070	····NDOMapping mapping;
8071	····Class ownClass;
8072	····Class otherClass;
8073	····Class ownDerivedClass;
8074	····[SetUp]
8075	····public void Setup()
8076	····{
8077	········this.pm = PmFactory.NewPersistenceManager();
8078	········this.mapping = pm.NDOMapping;
8079	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsTblGuidLeftBase" );
8080	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsTblGuidRight" );
8081	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsTblGuidLeftDerived" );
8082	····}
8083	····[Test]
8084	····public void HasMappingTable()
8085	····{
8086	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
8087	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
8088	····}
8089	····[Test]
8090	····public void HasTypeColumn()
8091	····{
8092	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
8093	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
8094	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
8095	····}
8096	····[Test]
8097	····public void HasTypeCode()
8098	····{
8099	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8100	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8101	····}
8102	}
8103
8104
8105	[TestFixture]
8106	public class MappingTestAgrBi11OwnpabsNoTblGuid : NDOTest
8107	{
8108	····PersistenceManager pm;
8109	····NDOMapping mapping;
8110	····Class ownClass;
8111	····Class otherClass;
8112	····Class ownDerivedClass;
8113	····[SetUp]
8114	····public void Setup()
8115	····{
8116	········this.pm = PmFactory.NewPersistenceManager();
8117	········this.mapping = pm.NDOMapping;
8118	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsNoTblGuidLeftBase" );
8119	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsNoTblGuidRight" );
8120	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsNoTblGuidLeftDerived" );
8121	····}
8122	····[Test]
8123	····public void HasMappingTable()
8124	····{
8125	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
8126	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
8127	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
8128	····}
8129	····[Test]
8130	····public void HasTypeColumn()
8131	····{
8132	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
8133	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #10");
8134	····}
8135	····[Test]
8136	····public void HasTypeCode()
8137	····{
8138	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8139	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8140	····}
8141	}
8142
8143
8144	[TestFixture]
8145	public class MappingTestAgrBi11OwnpabsTblGuid : NDOTest
8146	{
8147	····PersistenceManager pm;
8148	····NDOMapping mapping;
8149	····Class ownClass;
8150	····Class otherClass;
8151	····Class ownDerivedClass;
8152	····[SetUp]
8153	····public void Setup()
8154	····{
8155	········this.pm = PmFactory.NewPersistenceManager();
8156	········this.mapping = pm.NDOMapping;
8157	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsTblGuidLeftBase" );
8158	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsTblGuidRight" );
8159	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsTblGuidLeftDerived" );
8160	····}
8161	····[Test]
8162	····public void HasMappingTable()
8163	····{
8164	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
8165	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
8166	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
8167	····}
8168	····[Test]
8169	····public void HasTypeColumn()
8170	····{
8171	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
8172	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
8173	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
8174	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
8175	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
8176	····}
8177	····[Test]
8178	····public void HasTypeCode()
8179	····{
8180	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8181	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8182	····}
8183	}
8184
8185
8186	[TestFixture]
8187	public class MappingTestAgrDirnOwnpabsNoTblGuid : NDOTest
8188	{
8189	····PersistenceManager pm;
8190	····NDOMapping mapping;
8191	····Class ownClass;
8192	····Class otherClass;
8193	····Class ownDerivedClass;
8194	····[SetUp]
8195	····public void Setup()
8196	····{
8197	········this.pm = PmFactory.NewPersistenceManager();
8198	········this.mapping = pm.NDOMapping;
8199	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsNoTblGuidLeftBase" );
8200	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsNoTblGuidRight" );
8201	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsNoTblGuidLeftDerived" );
8202	····}
8203	····[Test]
8204	····public void HasMappingTable()
8205	····{
8206	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
8207	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
8208	····}
8209	····[Test]
8210	····public void HasTypeColumn()
8211	····{
8212	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
8213	····}
8214	····[Test]
8215	····public void HasTypeCode()
8216	····{
8217	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8218	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8219	····}
8220	}
8221
8222
8223	[TestFixture]
8224	public class MappingTestAgrDirnOwnpabsTblGuid : NDOTest
8225	{
8226	····PersistenceManager pm;
8227	····NDOMapping mapping;
8228	····Class ownClass;
8229	····Class otherClass;
8230	····Class ownDerivedClass;
8231	····[SetUp]
8232	····public void Setup()
8233	····{
8234	········this.pm = PmFactory.NewPersistenceManager();
8235	········this.mapping = pm.NDOMapping;
8236	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsTblGuidLeftBase" );
8237	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsTblGuidRight" );
8238	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsTblGuidLeftDerived" );
8239	····}
8240	····[Test]
8241	····public void HasMappingTable()
8242	····{
8243	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
8244	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
8245	····}
8246	····[Test]
8247	····public void HasTypeColumn()
8248	····{
8249	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
8250	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
8251	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
8252	····}
8253	····[Test]
8254	····public void HasTypeCode()
8255	····{
8256	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8257	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8258	····}
8259	}
8260
8261
8262	[TestFixture]
8263	public class MappingTestAgrBin1OwnpabsNoTblGuid : NDOTest
8264	{
8265	····PersistenceManager pm;
8266	····NDOMapping mapping;
8267	····Class ownClass;
8268	····Class otherClass;
8269	····Class ownDerivedClass;
8270	····[SetUp]
8271	····public void Setup()
8272	····{
8273	········this.pm = PmFactory.NewPersistenceManager();
8274	········this.mapping = pm.NDOMapping;
8275	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsNoTblGuidLeftBase" );
8276	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsNoTblGuidRight" );
8277	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsNoTblGuidLeftDerived" );
8278	····}
8279	····[Test]
8280	····public void HasMappingTable()
8281	····{
8282	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
8283	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
8284	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
8285	····}
8286	····[Test]
8287	····public void HasTypeColumn()
8288	····{
8289	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
8290	····}
8291	····[Test]
8292	····public void HasTypeCode()
8293	····{
8294	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8295	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8296	····}
8297	}
8298
8299
8300	[TestFixture]
8301	public class MappingTestAgrBin1OwnpabsTblGuid : NDOTest
8302	{
8303	····PersistenceManager pm;
8304	····NDOMapping mapping;
8305	····Class ownClass;
8306	····Class otherClass;
8307	····Class ownDerivedClass;
8308	····[SetUp]
8309	····public void Setup()
8310	····{
8311	········this.pm = PmFactory.NewPersistenceManager();
8312	········this.mapping = pm.NDOMapping;
8313	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsTblGuidLeftBase" );
8314	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsTblGuidRight" );
8315	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsTblGuidLeftDerived" );
8316	····}
8317	····[Test]
8318	····public void HasMappingTable()
8319	····{
8320	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
8321	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
8322	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
8323	····}
8324	····[Test]
8325	····public void HasTypeColumn()
8326	····{
8327	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
8328	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
8329	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
8330	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
8331	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
8332	····}
8333	····[Test]
8334	····public void HasTypeCode()
8335	····{
8336	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8337	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8338	····}
8339	}
8340
8341
8342	[TestFixture]
8343	public class MappingTestAgrBi1nOwnpabsTblGuid : NDOTest
8344	{
8345	····PersistenceManager pm;
8346	····NDOMapping mapping;
8347	····Class ownClass;
8348	····Class otherClass;
8349	····Class ownDerivedClass;
8350	····[SetUp]
8351	····public void Setup()
8352	····{
8353	········this.pm = PmFactory.NewPersistenceManager();
8354	········this.mapping = pm.NDOMapping;
8355	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsTblGuidLeftBase" );
8356	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsTblGuidRight" );
8357	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsTblGuidLeftDerived" );
8358	····}
8359	····[Test]
8360	····public void HasMappingTable()
8361	····{
8362	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
8363	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
8364	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
8365	····}
8366	····[Test]
8367	····public void HasTypeColumn()
8368	····{
8369	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
8370	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
8371	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
8372	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
8373	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
8374	····}
8375	····[Test]
8376	····public void HasTypeCode()
8377	····{
8378	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8379	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8380	····}
8381	}
8382
8383
8384	[TestFixture]
8385	public class MappingTestAgrBinnOwnpabsTblGuid : NDOTest
8386	{
8387	····PersistenceManager pm;
8388	····NDOMapping mapping;
8389	····Class ownClass;
8390	····Class otherClass;
8391	····Class ownDerivedClass;
8392	····[SetUp]
8393	····public void Setup()
8394	····{
8395	········this.pm = PmFactory.NewPersistenceManager();
8396	········this.mapping = pm.NDOMapping;
8397	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsTblGuidLeftBase" );
8398	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsTblGuidRight" );
8399	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsTblGuidLeftDerived" );
8400	····}
8401	····[Test]
8402	····public void HasMappingTable()
8403	····{
8404	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
8405	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
8406	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
8407	····}
8408	····[Test]
8409	····public void HasTypeColumn()
8410	····{
8411	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
8412	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
8413	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
8414	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
8415	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
8416	····}
8417	····[Test]
8418	····public void HasTypeCode()
8419	····{
8420	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8421	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8422	····}
8423	}
8424
8425
8426	[TestFixture]
8427	public class MappingTestCmpDir1OwnpabsNoTblGuid : NDOTest
8428	{
8429	····PersistenceManager pm;
8430	····NDOMapping mapping;
8431	····Class ownClass;
8432	····Class otherClass;
8433	····Class ownDerivedClass;
8434	····[SetUp]
8435	····public void Setup()
8436	····{
8437	········this.pm = PmFactory.NewPersistenceManager();
8438	········this.mapping = pm.NDOMapping;
8439	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsNoTblGuidLeftBase" );
8440	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsNoTblGuidRight" );
8441	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsNoTblGuidLeftDerived" );
8442	····}
8443	····[Test]
8444	····public void HasMappingTable()
8445	····{
8446	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
8447	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
8448	····}
8449	····[Test]
8450	····public void HasTypeColumn()
8451	····{
8452	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
8453	····}
8454	····[Test]
8455	····public void HasTypeCode()
8456	····{
8457	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8458	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8459	····}
8460	}
8461
8462
8463	[TestFixture]
8464	public class MappingTestCmpDir1OwnpabsTblGuid : NDOTest
8465	{
8466	····PersistenceManager pm;
8467	····NDOMapping mapping;
8468	····Class ownClass;
8469	····Class otherClass;
8470	····Class ownDerivedClass;
8471	····[SetUp]
8472	····public void Setup()
8473	····{
8474	········this.pm = PmFactory.NewPersistenceManager();
8475	········this.mapping = pm.NDOMapping;
8476	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsTblGuidLeftBase" );
8477	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsTblGuidRight" );
8478	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsTblGuidLeftDerived" );
8479	····}
8480	····[Test]
8481	····public void HasMappingTable()
8482	····{
8483	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
8484	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
8485	····}
8486	····[Test]
8487	····public void HasTypeColumn()
8488	····{
8489	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
8490	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
8491	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
8492	····}
8493	····[Test]
8494	····public void HasTypeCode()
8495	····{
8496	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8497	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8498	····}
8499	}
8500
8501
8502	[TestFixture]
8503	public class MappingTestCmpBi11OwnpabsNoTblGuid : NDOTest
8504	{
8505	····PersistenceManager pm;
8506	····NDOMapping mapping;
8507	····Class ownClass;
8508	····Class otherClass;
8509	····Class ownDerivedClass;
8510	····[SetUp]
8511	····public void Setup()
8512	····{
8513	········this.pm = PmFactory.NewPersistenceManager();
8514	········this.mapping = pm.NDOMapping;
8515	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsNoTblGuidLeftBase" );
8516	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsNoTblGuidRight" );
8517	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsNoTblGuidLeftDerived" );
8518	····}
8519	····[Test]
8520	····public void HasMappingTable()
8521	····{
8522	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
8523	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
8524	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
8525	····}
8526	····[Test]
8527	····public void HasTypeColumn()
8528	····{
8529	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
8530	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #10");
8531	····}
8532	····[Test]
8533	····public void HasTypeCode()
8534	····{
8535	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8536	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8537	····}
8538	}
8539
8540
8541	[TestFixture]
8542	public class MappingTestCmpBi11OwnpabsTblGuid : NDOTest
8543	{
8544	····PersistenceManager pm;
8545	····NDOMapping mapping;
8546	····Class ownClass;
8547	····Class otherClass;
8548	····Class ownDerivedClass;
8549	····[SetUp]
8550	····public void Setup()
8551	····{
8552	········this.pm = PmFactory.NewPersistenceManager();
8553	········this.mapping = pm.NDOMapping;
8554	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsTblGuidLeftBase" );
8555	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsTblGuidRight" );
8556	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsTblGuidLeftDerived" );
8557	····}
8558	····[Test]
8559	····public void HasMappingTable()
8560	····{
8561	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
8562	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
8563	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
8564	····}
8565	····[Test]
8566	····public void HasTypeColumn()
8567	····{
8568	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
8569	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
8570	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
8571	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
8572	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
8573	····}
8574	····[Test]
8575	····public void HasTypeCode()
8576	····{
8577	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8578	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8579	····}
8580	}
8581
8582
8583	[TestFixture]
8584	public class MappingTestCmpDirnOwnpabsNoTblGuid : NDOTest
8585	{
8586	····PersistenceManager pm;
8587	····NDOMapping mapping;
8588	····Class ownClass;
8589	····Class otherClass;
8590	····Class ownDerivedClass;
8591	····[SetUp]
8592	····public void Setup()
8593	····{
8594	········this.pm = PmFactory.NewPersistenceManager();
8595	········this.mapping = pm.NDOMapping;
8596	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsNoTblGuidLeftBase" );
8597	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsNoTblGuidRight" );
8598	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsNoTblGuidLeftDerived" );
8599	····}
8600	····[Test]
8601	····public void HasMappingTable()
8602	····{
8603	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
8604	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
8605	····}
8606	····[Test]
8607	····public void HasTypeColumn()
8608	····{
8609	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
8610	····}
8611	····[Test]
8612	····public void HasTypeCode()
8613	····{
8614	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8615	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8616	····}
8617	}
8618
8619
8620	[TestFixture]
8621	public class MappingTestCmpDirnOwnpabsTblGuid : NDOTest
8622	{
8623	····PersistenceManager pm;
8624	····NDOMapping mapping;
8625	····Class ownClass;
8626	····Class otherClass;
8627	····Class ownDerivedClass;
8628	····[SetUp]
8629	····public void Setup()
8630	····{
8631	········this.pm = PmFactory.NewPersistenceManager();
8632	········this.mapping = pm.NDOMapping;
8633	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsTblGuidLeftBase" );
8634	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsTblGuidRight" );
8635	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsTblGuidLeftDerived" );
8636	····}
8637	····[Test]
8638	····public void HasMappingTable()
8639	····{
8640	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
8641	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
8642	····}
8643	····[Test]
8644	····public void HasTypeColumn()
8645	····{
8646	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
8647	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
8648	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
8649	····}
8650	····[Test]
8651	····public void HasTypeCode()
8652	····{
8653	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8654	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8655	····}
8656	}
8657
8658
8659	[TestFixture]
8660	public class MappingTestCmpBin1OwnpabsNoTblGuid : NDOTest
8661	{
8662	····PersistenceManager pm;
8663	····NDOMapping mapping;
8664	····Class ownClass;
8665	····Class otherClass;
8666	····Class ownDerivedClass;
8667	····[SetUp]
8668	····public void Setup()
8669	····{
8670	········this.pm = PmFactory.NewPersistenceManager();
8671	········this.mapping = pm.NDOMapping;
8672	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsNoTblGuidLeftBase" );
8673	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsNoTblGuidRight" );
8674	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsNoTblGuidLeftDerived" );
8675	····}
8676	····[Test]
8677	····public void HasMappingTable()
8678	····{
8679	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
8680	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
8681	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
8682	····}
8683	····[Test]
8684	····public void HasTypeColumn()
8685	····{
8686	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
8687	····}
8688	····[Test]
8689	····public void HasTypeCode()
8690	····{
8691	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8692	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8693	····}
8694	}
8695
8696
8697	[TestFixture]
8698	public class MappingTestCmpBin1OwnpabsTblGuid : NDOTest
8699	{
8700	····PersistenceManager pm;
8701	····NDOMapping mapping;
8702	····Class ownClass;
8703	····Class otherClass;
8704	····Class ownDerivedClass;
8705	····[SetUp]
8706	····public void Setup()
8707	····{
8708	········this.pm = PmFactory.NewPersistenceManager();
8709	········this.mapping = pm.NDOMapping;
8710	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsTblGuidLeftBase" );
8711	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsTblGuidRight" );
8712	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsTblGuidLeftDerived" );
8713	····}
8714	····[Test]
8715	····public void HasMappingTable()
8716	····{
8717	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
8718	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
8719	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
8720	····}
8721	····[Test]
8722	····public void HasTypeColumn()
8723	····{
8724	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
8725	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
8726	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
8727	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
8728	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
8729	····}
8730	····[Test]
8731	····public void HasTypeCode()
8732	····{
8733	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8734	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8735	····}
8736	}
8737
8738
8739	[TestFixture]
8740	public class MappingTestCmpBi1nOwnpabsTblGuid : NDOTest
8741	{
8742	····PersistenceManager pm;
8743	····NDOMapping mapping;
8744	····Class ownClass;
8745	····Class otherClass;
8746	····Class ownDerivedClass;
8747	····[SetUp]
8748	····public void Setup()
8749	····{
8750	········this.pm = PmFactory.NewPersistenceManager();
8751	········this.mapping = pm.NDOMapping;
8752	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsTblGuidLeftBase" );
8753	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsTblGuidRight" );
8754	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsTblGuidLeftDerived" );
8755	····}
8756	····[Test]
8757	····public void HasMappingTable()
8758	····{
8759	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
8760	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
8761	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
8762	····}
8763	····[Test]
8764	····public void HasTypeColumn()
8765	····{
8766	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
8767	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
8768	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
8769	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
8770	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
8771	····}
8772	····[Test]
8773	····public void HasTypeCode()
8774	····{
8775	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8776	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8777	····}
8778	}
8779
8780
8781	[TestFixture]
8782	public class MappingTestCmpBinnOwnpabsTblGuid : NDOTest
8783	{
8784	····PersistenceManager pm;
8785	····NDOMapping mapping;
8786	····Class ownClass;
8787	····Class otherClass;
8788	····Class ownDerivedClass;
8789	····[SetUp]
8790	····public void Setup()
8791	····{
8792	········this.pm = PmFactory.NewPersistenceManager();
8793	········this.mapping = pm.NDOMapping;
8794	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsTblGuidLeftBase" );
8795	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsTblGuidRight" );
8796	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsTblGuidLeftDerived" );
8797	····}
8798	····[Test]
8799	····public void HasMappingTable()
8800	····{
8801	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
8802	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
8803	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
8804	····}
8805	····[Test]
8806	····public void HasTypeColumn()
8807	····{
8808	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
8809	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
8810	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
8811	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #3");
8812	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #4");
8813	····}
8814	····[Test]
8815	····public void HasTypeCode()
8816	····{
8817	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8818	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8819	····}
8820	}
8821
8822
8823	[TestFixture]
8824	public class MappingTestAgrDir1OthpabsNoTblGuid : NDOTest
8825	{
8826	····PersistenceManager pm;
8827	····NDOMapping mapping;
8828	····Class ownClass;
8829	····Class otherClass;
8830	····Class otherDerivedClass;
8831	····[SetUp]
8832	····public void Setup()
8833	····{
8834	········this.pm = PmFactory.NewPersistenceManager();
8835	········this.mapping = pm.NDOMapping;
8836	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsNoTblGuidLeft" );
8837	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsNoTblGuidRightBase" );
8838	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsNoTblGuidRightDerived" );
8839	····}
8840	····[Test]
8841	····public void HasMappingTable()
8842	····{
8843	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
8844	····}
8845	····[Test]
8846	····public void HasTypeColumn()
8847	····{
8848	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
8849	····}
8850	····[Test]
8851	····public void HasTypeCode()
8852	····{
8853	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
8854	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
8855	····}
8856	}
8857
8858
8859	[TestFixture]
8860	public class MappingTestAgrDir1OthpabsTblGuid : NDOTest
8861	{
8862	····PersistenceManager pm;
8863	····NDOMapping mapping;
8864	····Class ownClass;
8865	····Class otherClass;
8866	····Class otherDerivedClass;
8867	····[SetUp]
8868	····public void Setup()
8869	····{
8870	········this.pm = PmFactory.NewPersistenceManager();
8871	········this.mapping = pm.NDOMapping;
8872	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsTblGuidLeft" );
8873	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsTblGuidRightBase" );
8874	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsTblGuidRightDerived" );
8875	····}
8876	····[Test]
8877	····public void HasMappingTable()
8878	····{
8879	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
8880	····}
8881	····[Test]
8882	····public void HasTypeColumn()
8883	····{
8884	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
8885	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
8886	····}
8887	····[Test]
8888	····public void HasTypeCode()
8889	····{
8890	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
8891	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
8892	····}
8893	}
8894
8895
8896	[TestFixture]
8897	public class MappingTestAgrBi11OthpabsNoTblGuid : NDOTest
8898	{
8899	····PersistenceManager pm;
8900	····NDOMapping mapping;
8901	····Class ownClass;
8902	····Class otherClass;
8903	····Class otherDerivedClass;
8904	····[SetUp]
8905	····public void Setup()
8906	····{
8907	········this.pm = PmFactory.NewPersistenceManager();
8908	········this.mapping = pm.NDOMapping;
8909	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsNoTblGuidLeft" );
8910	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsNoTblGuidRightBase" );
8911	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsNoTblGuidRightDerived" );
8912	····}
8913	····[Test]
8914	····public void HasMappingTable()
8915	····{
8916	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
8917	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
8918	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
8919	····}
8920	····[Test]
8921	····public void HasTypeColumn()
8922	····{
8923	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
8924	····}
8925	····[Test]
8926	····public void HasTypeCode()
8927	····{
8928	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
8929	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
8930	····}
8931	}
8932
8933
8934	[TestFixture]
8935	public class MappingTestAgrBi11OthpabsTblGuid : NDOTest
8936	{
8937	····PersistenceManager pm;
8938	····NDOMapping mapping;
8939	····Class ownClass;
8940	····Class otherClass;
8941	····Class otherDerivedClass;
8942	····[SetUp]
8943	····public void Setup()
8944	····{
8945	········this.pm = PmFactory.NewPersistenceManager();
8946	········this.mapping = pm.NDOMapping;
8947	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsTblGuidLeft" );
8948	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsTblGuidRightBase" );
8949	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsTblGuidRightDerived" );
8950	····}
8951	····[Test]
8952	····public void HasMappingTable()
8953	····{
8954	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
8955	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
8956	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
8957	····}
8958	····[Test]
8959	····public void HasTypeColumn()
8960	····{
8961	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
8962	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
8963	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
8964	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
8965	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
8966	····}
8967	····[Test]
8968	····public void HasTypeCode()
8969	····{
8970	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
8971	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
8972	····}
8973	}
8974
8975
8976	[TestFixture]
8977	public class MappingTestAgrDirnOthpabsTblGuid : NDOTest
8978	{
8979	····PersistenceManager pm;
8980	····NDOMapping mapping;
8981	····Class ownClass;
8982	····Class otherClass;
8983	····Class otherDerivedClass;
8984	····[SetUp]
8985	····public void Setup()
8986	····{
8987	········this.pm = PmFactory.NewPersistenceManager();
8988	········this.mapping = pm.NDOMapping;
8989	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpabsTblGuidLeft" );
8990	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpabsTblGuidRightBase" );
8991	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpabsTblGuidRightDerived" );
8992	····}
8993	····[Test]
8994	····public void HasMappingTable()
8995	····{
8996	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
8997	····}
8998	····[Test]
8999	····public void HasTypeColumn()
9000	····{
9001	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
9002	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
9003	····}
9004	····[Test]
9005	····public void HasTypeCode()
9006	····{
9007	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9008	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9009	····}
9010	}
9011
9012
9013	[TestFixture]
9014	public class MappingTestAgrBin1OthpabsTblGuid : NDOTest
9015	{
9016	····PersistenceManager pm;
9017	····NDOMapping mapping;
9018	····Class ownClass;
9019	····Class otherClass;
9020	····Class otherDerivedClass;
9021	····[SetUp]
9022	····public void Setup()
9023	····{
9024	········this.pm = PmFactory.NewPersistenceManager();
9025	········this.mapping = pm.NDOMapping;
9026	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpabsTblGuidLeft" );
9027	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpabsTblGuidRightBase" );
9028	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpabsTblGuidRightDerived" );
9029	····}
9030	····[Test]
9031	····public void HasMappingTable()
9032	····{
9033	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
9034	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
9035	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
9036	····}
9037	····[Test]
9038	····public void HasTypeColumn()
9039	····{
9040	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
9041	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
9042	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
9043	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
9044	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
9045	····}
9046	····[Test]
9047	····public void HasTypeCode()
9048	····{
9049	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9050	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9051	····}
9052	}
9053
9054
9055	[TestFixture]
9056	public class MappingTestAgrBi1nOthpabsNoTblGuid : NDOTest
9057	{
9058	····PersistenceManager pm;
9059	····NDOMapping mapping;
9060	····Class ownClass;
9061	····Class otherClass;
9062	····Class otherDerivedClass;
9063	····[SetUp]
9064	····public void Setup()
9065	····{
9066	········this.pm = PmFactory.NewPersistenceManager();
9067	········this.mapping = pm.NDOMapping;
9068	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsNoTblGuidLeft" );
9069	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsNoTblGuidRightBase" );
9070	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsNoTblGuidRightDerived" );
9071	····}
9072	····[Test]
9073	····public void HasMappingTable()
9074	····{
9075	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
9076	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
9077	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
9078	····}
9079	····[Test]
9080	····public void HasTypeColumn()
9081	····{
9082	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
9083	····}
9084	····[Test]
9085	····public void HasTypeCode()
9086	····{
9087	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9088	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9089	····}
9090	}
9091
9092
9093	[TestFixture]
9094	public class MappingTestAgrBi1nOthpabsTblGuid : NDOTest
9095	{
9096	····PersistenceManager pm;
9097	····NDOMapping mapping;
9098	····Class ownClass;
9099	····Class otherClass;
9100	····Class otherDerivedClass;
9101	····[SetUp]
9102	····public void Setup()
9103	····{
9104	········this.pm = PmFactory.NewPersistenceManager();
9105	········this.mapping = pm.NDOMapping;
9106	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsTblGuidLeft" );
9107	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsTblGuidRightBase" );
9108	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsTblGuidRightDerived" );
9109	····}
9110	····[Test]
9111	····public void HasMappingTable()
9112	····{
9113	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
9114	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
9115	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
9116	····}
9117	····[Test]
9118	····public void HasTypeColumn()
9119	····{
9120	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
9121	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
9122	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
9123	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
9124	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
9125	····}
9126	····[Test]
9127	····public void HasTypeCode()
9128	····{
9129	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9130	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9131	····}
9132	}
9133
9134
9135	[TestFixture]
9136	public class MappingTestAgrBinnOthpabsTblGuid : NDOTest
9137	{
9138	····PersistenceManager pm;
9139	····NDOMapping mapping;
9140	····Class ownClass;
9141	····Class otherClass;
9142	····Class otherDerivedClass;
9143	····[SetUp]
9144	····public void Setup()
9145	····{
9146	········this.pm = PmFactory.NewPersistenceManager();
9147	········this.mapping = pm.NDOMapping;
9148	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpabsTblGuidLeft" );
9149	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpabsTblGuidRightBase" );
9150	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpabsTblGuidRightDerived" );
9151	····}
9152	····[Test]
9153	····public void HasMappingTable()
9154	····{
9155	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
9156	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
9157	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
9158	····}
9159	····[Test]
9160	····public void HasTypeColumn()
9161	····{
9162	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
9163	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
9164	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
9165	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
9166	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
9167	····}
9168	····[Test]
9169	····public void HasTypeCode()
9170	····{
9171	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9172	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9173	····}
9174	}
9175
9176
9177	[TestFixture]
9178	public class MappingTestCmpDir1OthpabsNoTblGuid : NDOTest
9179	{
9180	····PersistenceManager pm;
9181	····NDOMapping mapping;
9182	····Class ownClass;
9183	····Class otherClass;
9184	····Class otherDerivedClass;
9185	····[SetUp]
9186	····public void Setup()
9187	····{
9188	········this.pm = PmFactory.NewPersistenceManager();
9189	········this.mapping = pm.NDOMapping;
9190	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsNoTblGuidLeft" );
9191	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsNoTblGuidRightBase" );
9192	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsNoTblGuidRightDerived" );
9193	····}
9194	····[Test]
9195	····public void HasMappingTable()
9196	····{
9197	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
9198	····}
9199	····[Test]
9200	····public void HasTypeColumn()
9201	····{
9202	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
9203	····}
9204	····[Test]
9205	····public void HasTypeCode()
9206	····{
9207	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9208	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9209	····}
9210	}
9211
9212
9213	[TestFixture]
9214	public class MappingTestCmpDir1OthpabsTblGuid : NDOTest
9215	{
9216	····PersistenceManager pm;
9217	····NDOMapping mapping;
9218	····Class ownClass;
9219	····Class otherClass;
9220	····Class otherDerivedClass;
9221	····[SetUp]
9222	····public void Setup()
9223	····{
9224	········this.pm = PmFactory.NewPersistenceManager();
9225	········this.mapping = pm.NDOMapping;
9226	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsTblGuidLeft" );
9227	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsTblGuidRightBase" );
9228	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsTblGuidRightDerived" );
9229	····}
9230	····[Test]
9231	····public void HasMappingTable()
9232	····{
9233	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
9234	····}
9235	····[Test]
9236	····public void HasTypeColumn()
9237	····{
9238	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
9239	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
9240	····}
9241	····[Test]
9242	····public void HasTypeCode()
9243	····{
9244	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9245	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9246	····}
9247	}
9248
9249
9250	[TestFixture]
9251	public class MappingTestCmpBi11OthpabsNoTblGuid : NDOTest
9252	{
9253	····PersistenceManager pm;
9254	····NDOMapping mapping;
9255	····Class ownClass;
9256	····Class otherClass;
9257	····Class otherDerivedClass;
9258	····[SetUp]
9259	····public void Setup()
9260	····{
9261	········this.pm = PmFactory.NewPersistenceManager();
9262	········this.mapping = pm.NDOMapping;
9263	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsNoTblGuidLeft" );
9264	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsNoTblGuidRightBase" );
9265	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsNoTblGuidRightDerived" );
9266	····}
9267	····[Test]
9268	····public void HasMappingTable()
9269	····{
9270	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
9271	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
9272	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
9273	····}
9274	····[Test]
9275	····public void HasTypeColumn()
9276	····{
9277	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
9278	····}
9279	····[Test]
9280	····public void HasTypeCode()
9281	····{
9282	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9283	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9284	····}
9285	}
9286
9287
9288	[TestFixture]
9289	public class MappingTestCmpBi11OthpabsTblGuid : NDOTest
9290	{
9291	····PersistenceManager pm;
9292	····NDOMapping mapping;
9293	····Class ownClass;
9294	····Class otherClass;
9295	····Class otherDerivedClass;
9296	····[SetUp]
9297	····public void Setup()
9298	····{
9299	········this.pm = PmFactory.NewPersistenceManager();
9300	········this.mapping = pm.NDOMapping;
9301	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsTblGuidLeft" );
9302	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsTblGuidRightBase" );
9303	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsTblGuidRightDerived" );
9304	····}
9305	····[Test]
9306	····public void HasMappingTable()
9307	····{
9308	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
9309	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
9310	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
9311	····}
9312	····[Test]
9313	····public void HasTypeColumn()
9314	····{
9315	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
9316	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
9317	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
9318	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
9319	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
9320	····}
9321	····[Test]
9322	····public void HasTypeCode()
9323	····{
9324	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9325	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9326	····}
9327	}
9328
9329
9330	[TestFixture]
9331	public class MappingTestCmpDirnOthpabsTblGuid : NDOTest
9332	{
9333	····PersistenceManager pm;
9334	····NDOMapping mapping;
9335	····Class ownClass;
9336	····Class otherClass;
9337	····Class otherDerivedClass;
9338	····[SetUp]
9339	····public void Setup()
9340	····{
9341	········this.pm = PmFactory.NewPersistenceManager();
9342	········this.mapping = pm.NDOMapping;
9343	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpabsTblGuidLeft" );
9344	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpabsTblGuidRightBase" );
9345	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpabsTblGuidRightDerived" );
9346	····}
9347	····[Test]
9348	····public void HasMappingTable()
9349	····{
9350	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
9351	····}
9352	····[Test]
9353	····public void HasTypeColumn()
9354	····{
9355	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
9356	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
9357	····}
9358	····[Test]
9359	····public void HasTypeCode()
9360	····{
9361	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9362	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9363	····}
9364	}
9365
9366
9367	[TestFixture]
9368	public class MappingTestCmpBin1OthpabsTblGuid : NDOTest
9369	{
9370	····PersistenceManager pm;
9371	····NDOMapping mapping;
9372	····Class ownClass;
9373	····Class otherClass;
9374	····Class otherDerivedClass;
9375	····[SetUp]
9376	····public void Setup()
9377	····{
9378	········this.pm = PmFactory.NewPersistenceManager();
9379	········this.mapping = pm.NDOMapping;
9380	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpabsTblGuidLeft" );
9381	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpabsTblGuidRightBase" );
9382	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpabsTblGuidRightDerived" );
9383	····}
9384	····[Test]
9385	····public void HasMappingTable()
9386	····{
9387	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
9388	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
9389	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
9390	····}
9391	····[Test]
9392	····public void HasTypeColumn()
9393	····{
9394	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
9395	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
9396	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
9397	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
9398	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
9399	····}
9400	····[Test]
9401	····public void HasTypeCode()
9402	····{
9403	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9404	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9405	····}
9406	}
9407
9408
9409	[TestFixture]
9410	public class MappingTestCmpBi1nOthpabsNoTblGuid : NDOTest
9411	{
9412	····PersistenceManager pm;
9413	····NDOMapping mapping;
9414	····Class ownClass;
9415	····Class otherClass;
9416	····Class otherDerivedClass;
9417	····[SetUp]
9418	····public void Setup()
9419	····{
9420	········this.pm = PmFactory.NewPersistenceManager();
9421	········this.mapping = pm.NDOMapping;
9422	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsNoTblGuidLeft" );
9423	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsNoTblGuidRightBase" );
9424	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsNoTblGuidRightDerived" );
9425	····}
9426	····[Test]
9427	····public void HasMappingTable()
9428	····{
9429	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
9430	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
9431	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
9432	····}
9433	····[Test]
9434	····public void HasTypeColumn()
9435	····{
9436	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
9437	····}
9438	····[Test]
9439	····public void HasTypeCode()
9440	····{
9441	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9442	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9443	····}
9444	}
9445
9446
9447	[TestFixture]
9448	public class MappingTestCmpBi1nOthpabsTblGuid : NDOTest
9449	{
9450	····PersistenceManager pm;
9451	····NDOMapping mapping;
9452	····Class ownClass;
9453	····Class otherClass;
9454	····Class otherDerivedClass;
9455	····[SetUp]
9456	····public void Setup()
9457	····{
9458	········this.pm = PmFactory.NewPersistenceManager();
9459	········this.mapping = pm.NDOMapping;
9460	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsTblGuidLeft" );
9461	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsTblGuidRightBase" );
9462	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsTblGuidRightDerived" );
9463	····}
9464	····[Test]
9465	····public void HasMappingTable()
9466	····{
9467	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
9468	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
9469	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
9470	····}
9471	····[Test]
9472	····public void HasTypeColumn()
9473	····{
9474	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
9475	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
9476	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
9477	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
9478	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
9479	····}
9480	····[Test]
9481	····public void HasTypeCode()
9482	····{
9483	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9484	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9485	····}
9486	}
9487
9488
9489	[TestFixture]
9490	public class MappingTestCmpBinnOthpabsTblGuid : NDOTest
9491	{
9492	····PersistenceManager pm;
9493	····NDOMapping mapping;
9494	····Class ownClass;
9495	····Class otherClass;
9496	····Class otherDerivedClass;
9497	····[SetUp]
9498	····public void Setup()
9499	····{
9500	········this.pm = PmFactory.NewPersistenceManager();
9501	········this.mapping = pm.NDOMapping;
9502	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpabsTblGuidLeft" );
9503	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpabsTblGuidRightBase" );
9504	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpabsTblGuidRightDerived" );
9505	····}
9506	····[Test]
9507	····public void HasMappingTable()
9508	····{
9509	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
9510	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
9511	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
9512	····}
9513	····[Test]
9514	····public void HasTypeColumn()
9515	····{
9516	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
9517	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
9518	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
9519	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #1");
9520	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Null, "Relation shouldn't have a TypeColumn #2");
9521	····}
9522	····[Test]
9523	····public void HasTypeCode()
9524	····{
9525	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9526	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9527	····}
9528	}
9529
9530
9531	[TestFixture]
9532	public class MappingTestAgrDir1OwnpabsOthpabsNoTblGuid : NDOTest
9533	{
9534	····PersistenceManager pm;
9535	····NDOMapping mapping;
9536	····Class ownClass;
9537	····Class otherClass;
9538	····Class ownDerivedClass;
9539	····Class otherDerivedClass;
9540	····[SetUp]
9541	····public void Setup()
9542	····{
9543	········this.pm = PmFactory.NewPersistenceManager();
9544	········this.mapping = pm.NDOMapping;
9545	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsNoTblGuidLeftBase" );
9546	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsNoTblGuidRightBase" );
9547	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsNoTblGuidLeftDerived" );
9548	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsNoTblGuidRightDerived" );
9549	····}
9550	····[Test]
9551	····public void HasMappingTable()
9552	····{
9553	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
9554	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
9555	····}
9556	····[Test]
9557	····public void HasTypeColumn()
9558	····{
9559	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
9560	····}
9561	····[Test]
9562	····public void HasTypeCode()
9563	····{
9564	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9565	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9566	····}
9567	}
9568
9569
9570	[TestFixture]
9571	public class MappingTestAgrDir1OwnpabsOthpabsTblGuid : NDOTest
9572	{
9573	····PersistenceManager pm;
9574	····NDOMapping mapping;
9575	····Class ownClass;
9576	····Class otherClass;
9577	····Class ownDerivedClass;
9578	····Class otherDerivedClass;
9579	····[SetUp]
9580	····public void Setup()
9581	····{
9582	········this.pm = PmFactory.NewPersistenceManager();
9583	········this.mapping = pm.NDOMapping;
9584	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsTblGuidLeftBase" );
9585	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsTblGuidRightBase" );
9586	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsTblGuidLeftDerived" );
9587	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsTblGuidRightDerived" );
9588	····}
9589	····[Test]
9590	····public void HasMappingTable()
9591	····{
9592	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
9593	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
9594	····}
9595	····[Test]
9596	····public void HasTypeColumn()
9597	····{
9598	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
9599	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
9600	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
9601	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
9602	····}
9603	····[Test]
9604	····public void HasTypeCode()
9605	····{
9606	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9607	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9608	····}
9609	}
9610
9611
9612	[TestFixture]
9613	public class MappingTestAgrBi11OwnpabsOthpabsNoTblGuid : NDOTest
9614	{
9615	····PersistenceManager pm;
9616	····NDOMapping mapping;
9617	····Class ownClass;
9618	····Class otherClass;
9619	····Class ownDerivedClass;
9620	····Class otherDerivedClass;
9621	····[SetUp]
9622	····public void Setup()
9623	····{
9624	········this.pm = PmFactory.NewPersistenceManager();
9625	········this.mapping = pm.NDOMapping;
9626	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsNoTblGuidLeftBase" );
9627	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsNoTblGuidRightBase" );
9628	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsNoTblGuidLeftDerived" );
9629	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsNoTblGuidRightDerived" );
9630	····}
9631	····[Test]
9632	····public void HasMappingTable()
9633	····{
9634	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
9635	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
9636	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
9637	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
9638	····}
9639	····[Test]
9640	····public void HasTypeColumn()
9641	····{
9642	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
9643	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #10");
9644	····}
9645	····[Test]
9646	····public void HasTypeCode()
9647	····{
9648	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9649	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9650	····}
9651	}
9652
9653
9654	[TestFixture]
9655	public class MappingTestAgrBi11OwnpabsOthpabsTblGuid : NDOTest
9656	{
9657	····PersistenceManager pm;
9658	····NDOMapping mapping;
9659	····Class ownClass;
9660	····Class otherClass;
9661	····Class ownDerivedClass;
9662	····Class otherDerivedClass;
9663	····[SetUp]
9664	····public void Setup()
9665	····{
9666	········this.pm = PmFactory.NewPersistenceManager();
9667	········this.mapping = pm.NDOMapping;
9668	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsTblGuidLeftBase" );
9669	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsTblGuidRightBase" );
9670	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsTblGuidLeftDerived" );
9671	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsTblGuidRightDerived" );
9672	····}
9673	····[Test]
9674	····public void HasMappingTable()
9675	····{
9676	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
9677	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
9678	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
9679	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
9680	····}
9681	····[Test]
9682	····public void HasTypeColumn()
9683	····{
9684	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
9685	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
9686	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
9687	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
9688	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
9689	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
9690	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
9691	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
9692	····}
9693	····[Test]
9694	····public void HasTypeCode()
9695	····{
9696	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9697	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9698	····}
9699	}
9700
9701
9702	[TestFixture]
9703	public class MappingTestAgrDirnOwnpabsOthpabsTblGuid : NDOTest
9704	{
9705	····PersistenceManager pm;
9706	····NDOMapping mapping;
9707	····Class ownClass;
9708	····Class otherClass;
9709	····Class ownDerivedClass;
9710	····Class otherDerivedClass;
9711	····[SetUp]
9712	····public void Setup()
9713	····{
9714	········this.pm = PmFactory.NewPersistenceManager();
9715	········this.mapping = pm.NDOMapping;
9716	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsOthpabsTblGuidLeftBase" );
9717	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsOthpabsTblGuidRightBase" );
9718	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsOthpabsTblGuidLeftDerived" );
9719	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsOthpabsTblGuidRightDerived" );
9720	····}
9721	····[Test]
9722	····public void HasMappingTable()
9723	····{
9724	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
9725	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
9726	····}
9727	····[Test]
9728	····public void HasTypeColumn()
9729	····{
9730	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
9731	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
9732	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
9733	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
9734	····}
9735	····[Test]
9736	····public void HasTypeCode()
9737	····{
9738	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9739	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9740	····}
9741	}
9742
9743
9744	[TestFixture]
9745	public class MappingTestAgrBin1OwnpabsOthpabsTblGuid : NDOTest
9746	{
9747	····PersistenceManager pm;
9748	····NDOMapping mapping;
9749	····Class ownClass;
9750	····Class otherClass;
9751	····Class ownDerivedClass;
9752	····Class otherDerivedClass;
9753	····[SetUp]
9754	····public void Setup()
9755	····{
9756	········this.pm = PmFactory.NewPersistenceManager();
9757	········this.mapping = pm.NDOMapping;
9758	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsOthpabsTblGuidLeftBase" );
9759	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsOthpabsTblGuidRightBase" );
9760	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsOthpabsTblGuidLeftDerived" );
9761	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsOthpabsTblGuidRightDerived" );
9762	····}
9763	····[Test]
9764	····public void HasMappingTable()
9765	····{
9766	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
9767	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
9768	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
9769	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
9770	····}
9771	····[Test]
9772	····public void HasTypeColumn()
9773	····{
9774	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
9775	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
9776	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
9777	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
9778	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
9779	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
9780	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
9781	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
9782	····}
9783	····[Test]
9784	····public void HasTypeCode()
9785	····{
9786	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9787	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9788	····}
9789	}
9790
9791
9792	[TestFixture]
9793	public class MappingTestAgrBi1nOwnpabsOthpabsTblGuid : NDOTest
9794	{
9795	····PersistenceManager pm;
9796	····NDOMapping mapping;
9797	····Class ownClass;
9798	····Class otherClass;
9799	····Class ownDerivedClass;
9800	····Class otherDerivedClass;
9801	····[SetUp]
9802	····public void Setup()
9803	····{
9804	········this.pm = PmFactory.NewPersistenceManager();
9805	········this.mapping = pm.NDOMapping;
9806	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsOthpabsTblGuidLeftBase" );
9807	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsOthpabsTblGuidRightBase" );
9808	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsOthpabsTblGuidLeftDerived" );
9809	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsOthpabsTblGuidRightDerived" );
9810	····}
9811	····[Test]
9812	····public void HasMappingTable()
9813	····{
9814	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
9815	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
9816	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
9817	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
9818	····}
9819	····[Test]
9820	····public void HasTypeColumn()
9821	····{
9822	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
9823	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
9824	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
9825	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
9826	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
9827	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
9828	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
9829	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
9830	····}
9831	····[Test]
9832	····public void HasTypeCode()
9833	····{
9834	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9835	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9836	····}
9837	}
9838
9839
9840	[TestFixture]
9841	public class MappingTestAgrBinnOwnpabsOthpabsTblGuid : NDOTest
9842	{
9843	····PersistenceManager pm;
9844	····NDOMapping mapping;
9845	····Class ownClass;
9846	····Class otherClass;
9847	····Class ownDerivedClass;
9848	····Class otherDerivedClass;
9849	····[SetUp]
9850	····public void Setup()
9851	····{
9852	········this.pm = PmFactory.NewPersistenceManager();
9853	········this.mapping = pm.NDOMapping;
9854	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsOthpabsTblGuidLeftBase" );
9855	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsOthpabsTblGuidRightBase" );
9856	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsOthpabsTblGuidLeftDerived" );
9857	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsOthpabsTblGuidRightDerived" );
9858	····}
9859	····[Test]
9860	····public void HasMappingTable()
9861	····{
9862	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
9863	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
9864	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
9865	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
9866	····}
9867	····[Test]
9868	····public void HasTypeColumn()
9869	····{
9870	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
9871	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
9872	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
9873	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
9874	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
9875	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
9876	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
9877	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
9878	····}
9879	····[Test]
9880	····public void HasTypeCode()
9881	····{
9882	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9883	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9884	····}
9885	}
9886
9887
9888	[TestFixture]
9889	public class MappingTestCmpDir1OwnpabsOthpabsNoTblGuid : NDOTest
9890	{
9891	····PersistenceManager pm;
9892	····NDOMapping mapping;
9893	····Class ownClass;
9894	····Class otherClass;
9895	····Class ownDerivedClass;
9896	····Class otherDerivedClass;
9897	····[SetUp]
9898	····public void Setup()
9899	····{
9900	········this.pm = PmFactory.NewPersistenceManager();
9901	········this.mapping = pm.NDOMapping;
9902	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsNoTblGuidLeftBase" );
9903	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsNoTblGuidRightBase" );
9904	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsNoTblGuidLeftDerived" );
9905	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsNoTblGuidRightDerived" );
9906	····}
9907	····[Test]
9908	····public void HasMappingTable()
9909	····{
9910	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
9911	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
9912	····}
9913	····[Test]
9914	····public void HasTypeColumn()
9915	····{
9916	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
9917	····}
9918	····[Test]
9919	····public void HasTypeCode()
9920	····{
9921	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9922	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9923	····}
9924	}
9925
9926
9927	[TestFixture]
9928	public class MappingTestCmpDir1OwnpabsOthpabsTblGuid : NDOTest
9929	{
9930	····PersistenceManager pm;
9931	····NDOMapping mapping;
9932	····Class ownClass;
9933	····Class otherClass;
9934	····Class ownDerivedClass;
9935	····Class otherDerivedClass;
9936	····[SetUp]
9937	····public void Setup()
9938	····{
9939	········this.pm = PmFactory.NewPersistenceManager();
9940	········this.mapping = pm.NDOMapping;
9941	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsTblGuidLeftBase" );
9942	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsTblGuidRightBase" );
9943	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsTblGuidLeftDerived" );
9944	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsTblGuidRightDerived" );
9945	····}
9946	····[Test]
9947	····public void HasMappingTable()
9948	····{
9949	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
9950	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
9951	····}
9952	····[Test]
9953	····public void HasTypeColumn()
9954	····{
9955	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
9956	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
9957	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
9958	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
9959	····}
9960	····[Test]
9961	····public void HasTypeCode()
9962	····{
9963	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9964	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9965	····}
9966	}
9967
9968
9969	[TestFixture]
9970	public class MappingTestCmpBi11OwnpabsOthpabsNoTblGuid : NDOTest
9971	{
9972	····PersistenceManager pm;
9973	····NDOMapping mapping;
9974	····Class ownClass;
9975	····Class otherClass;
9976	····Class ownDerivedClass;
9977	····Class otherDerivedClass;
9978	····[SetUp]
9979	····public void Setup()
9980	····{
9981	········this.pm = PmFactory.NewPersistenceManager();
9982	········this.mapping = pm.NDOMapping;
9983	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsNoTblGuidLeftBase" );
9984	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsNoTblGuidRightBase" );
9985	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsNoTblGuidLeftDerived" );
9986	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsNoTblGuidRightDerived" );
9987	····}
9988	····[Test]
9989	····public void HasMappingTable()
9990	····{
9991	········Assert.That(ownClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #5");
9992	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #6");
9993	········Assert.That(otherClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #7");
9994	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Null, "Relation shouldn't have a MappingTable #8");
9995	····}
9996	····[Test]
9997	····public void HasTypeColumn()
9998	····{
9999	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #9");
10000	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #10");
10001	····}
10002	····[Test]
10003	····public void HasTypeCode()
10004	····{
10005	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
10006	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
10007	····}
10008	}
10009
10010
10011	[TestFixture]
10012	public class MappingTestCmpBi11OwnpabsOthpabsTblGuid : NDOTest
10013	{
10014	····PersistenceManager pm;
10015	····NDOMapping mapping;
10016	····Class ownClass;
10017	····Class otherClass;
10018	····Class ownDerivedClass;
10019	····Class otherDerivedClass;
10020	····[SetUp]
10021	····public void Setup()
10022	····{
10023	········this.pm = PmFactory.NewPersistenceManager();
10024	········this.mapping = pm.NDOMapping;
10025	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsTblGuidLeftBase" );
10026	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsTblGuidRightBase" );
10027	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsTblGuidLeftDerived" );
10028	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsTblGuidRightDerived" );
10029	····}
10030	····[Test]
10031	····public void HasMappingTable()
10032	····{
10033	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
10034	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
10035	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
10036	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
10037	····}
10038	····[Test]
10039	····public void HasTypeColumn()
10040	····{
10041	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
10042	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
10043	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
10044	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
10045	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
10046	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
10047	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
10048	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
10049	····}
10050	····[Test]
10051	····public void HasTypeCode()
10052	····{
10053	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
10054	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
10055	····}
10056	}
10057
10058
10059	[TestFixture]
10060	public class MappingTestCmpDirnOwnpabsOthpabsTblGuid : NDOTest
10061	{
10062	····PersistenceManager pm;
10063	····NDOMapping mapping;
10064	····Class ownClass;
10065	····Class otherClass;
10066	····Class ownDerivedClass;
10067	····Class otherDerivedClass;
10068	····[SetUp]
10069	····public void Setup()
10070	····{
10071	········this.pm = PmFactory.NewPersistenceManager();
10072	········this.mapping = pm.NDOMapping;
10073	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsOthpabsTblGuidLeftBase" );
10074	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsOthpabsTblGuidRightBase" );
10075	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsOthpabsTblGuidLeftDerived" );
10076	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsOthpabsTblGuidRightDerived" );
10077	····}
10078	····[Test]
10079	····public void HasMappingTable()
10080	····{
10081	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
10082	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
10083	····}
10084	····[Test]
10085	····public void HasTypeColumn()
10086	····{
10087	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
10088	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
10089	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
10090	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
10091	····}
10092	····[Test]
10093	····public void HasTypeCode()
10094	····{
10095	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
10096	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
10097	····}
10098	}
10099
10100
10101	[TestFixture]
10102	public class MappingTestCmpBin1OwnpabsOthpabsTblGuid : NDOTest
10103	{
10104	····PersistenceManager pm;
10105	····NDOMapping mapping;
10106	····Class ownClass;
10107	····Class otherClass;
10108	····Class ownDerivedClass;
10109	····Class otherDerivedClass;
10110	····[SetUp]
10111	····public void Setup()
10112	····{
10113	········this.pm = PmFactory.NewPersistenceManager();
10114	········this.mapping = pm.NDOMapping;
10115	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsOthpabsTblGuidLeftBase" );
10116	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsOthpabsTblGuidRightBase" );
10117	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsOthpabsTblGuidLeftDerived" );
10118	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsOthpabsTblGuidRightDerived" );
10119	····}
10120	····[Test]
10121	····public void HasMappingTable()
10122	····{
10123	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
10124	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
10125	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
10126	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
10127	····}
10128	····[Test]
10129	····public void HasTypeColumn()
10130	····{
10131	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
10132	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
10133	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
10134	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
10135	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
10136	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
10137	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
10138	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
10139	····}
10140	····[Test]
10141	····public void HasTypeCode()
10142	····{
10143	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
10144	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
10145	····}
10146	}
10147
10148
10149	[TestFixture]
10150	public class MappingTestCmpBi1nOwnpabsOthpabsTblGuid : NDOTest
10151	{
10152	····PersistenceManager pm;
10153	····NDOMapping mapping;
10154	····Class ownClass;
10155	····Class otherClass;
10156	····Class ownDerivedClass;
10157	····Class otherDerivedClass;
10158	····[SetUp]
10159	····public void Setup()
10160	····{
10161	········this.pm = PmFactory.NewPersistenceManager();
10162	········this.mapping = pm.NDOMapping;
10163	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsOthpabsTblGuidLeftBase" );
10164	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsOthpabsTblGuidRightBase" );
10165	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsOthpabsTblGuidLeftDerived" );
10166	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsOthpabsTblGuidRightDerived" );
10167	····}
10168	····[Test]
10169	····public void HasMappingTable()
10170	····{
10171	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
10172	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
10173	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
10174	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
10175	····}
10176	····[Test]
10177	····public void HasTypeColumn()
10178	····{
10179	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
10180	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
10181	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
10182	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
10183	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
10184	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
10185	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
10186	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
10187	····}
10188	····[Test]
10189	····public void HasTypeCode()
10190	····{
10191	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
10192	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
10193	····}
10194	}
10195
10196
10197	[TestFixture]
10198	public class MappingTestCmpBinnOwnpabsOthpabsTblGuid : NDOTest
10199	{
10200	····PersistenceManager pm;
10201	····NDOMapping mapping;
10202	····Class ownClass;
10203	····Class otherClass;
10204	····Class ownDerivedClass;
10205	····Class otherDerivedClass;
10206	····[SetUp]
10207	····public void Setup()
10208	····{
10209	········this.pm = PmFactory.NewPersistenceManager();
10210	········this.mapping = pm.NDOMapping;
10211	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsOthpabsTblGuidLeftBase" );
10212	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsOthpabsTblGuidRightBase" );
10213	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsOthpabsTblGuidLeftDerived" );
10214	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsOthpabsTblGuidRightDerived" );
10215	····}
10216	····[Test]
10217	····public void HasMappingTable()
10218	····{
10219	········Assert.That(ownClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #1");
10220	········Assert.That(ownDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #2");
10221	········Assert.That(otherClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #3");
10222	········Assert.That(otherDerivedClass.Relations.First().MappingTable, Is.Not.Null, "Relation should have a MappingTable #4");
10223	····}
10224	····[Test]
10225	····public void HasTypeColumn()
10226	····{
10227	········Assert.That(ownClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #1");
10228	········Assert.That(ownDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #2");
10229	········Assert.That(ownClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #3");
10230	········Assert.That(ownDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #4");
10231	········Assert.That(otherClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #5");
10232	········Assert.That(otherDerivedClass.Relations.First().ForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #6");
10233	········Assert.That(otherClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #7");
10234	········Assert.That(otherDerivedClass.Relations.First().MappingTable.ChildForeignKeyTypeColumnName, Is.Not.Null, "Relation should have a TypeColumn #8");
10235	····}
10236	····[Test]
10237	····public void HasTypeCode()
10238	····{
10239	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
10240	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
10241	····}
10242	}
10243
10244
10245
10246	}
10247

Cookie Info