Datei: UnitTestGenerator/UnitTests/MappingUnitTests.cs

Last Commit (0bec001)

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	namespace MappingUnitTests
32	{
33
34	public class PmFactory
35	{
36	····static PersistenceManager pm;
37	····public static PersistenceManager NewPersistenceManager()
38	····{
39	········if (pm == null)
40	········{
41	pm = new PersistenceManager( @"C:\Projekte\NDO\UnitTestGenerator\UnitTests\bin\Debug\NDOMapping. xml") ;
42	········}
43	········else
44	········{
45	············pm.UnloadCache();
46	········}
47	········return pm;
48	····}
49	}
50
51
52	[TestFixture]
53	public class MappingTestAgrDir1NoTblAuto
54	{
55	····PersistenceManager pm;
56	····NDOMapping mapping;
57	····Class ownClass;
58	····Class otherClass;
59	····[SetUp]
60	····public void Setup()
61	····{
62	········this.pm = PmFactory.NewPersistenceManager();
63	········this.mapping = pm.NDOMapping;
64	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1NoTblAutoLeft" );
65	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1NoTblAutoRight" );
66	····}
67	····[Test]
68	····public void HasMappingTable()
69	····{
70	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
71	····}
72	····[Test]
73	····public void HasTypeColumn()
74	····{
75	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
76	····}
77	····[Test]
78	····public void HasTypeCode()
79	····{
80	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
81	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
82	····}
83	}
84
85
86	[TestFixture]
87	public class MappingTestAgrDir1TblAuto
88	{
89	····PersistenceManager pm;
90	····NDOMapping mapping;
91	····Class ownClass;
92	····Class otherClass;
93	····[SetUp]
94	····public void Setup()
95	····{
96	········this.pm = PmFactory.NewPersistenceManager();
97	········this.mapping = pm.NDOMapping;
98	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1TblAutoLeft" );
99	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1TblAutoRight" );
100	····}
101	····[Test]
102	····public void HasMappingTable()
103	····{
104	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
105	····}
106	····[Test]
107	····public void HasTypeColumn()
108	····{
109	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
110	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
111	····}
112	····[Test]
113	····public void HasTypeCode()
114	····{
115	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
116	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
117	····}
118	}
119
120
121	[TestFixture]
122	public class MappingTestAgrBi11NoTblAuto
123	{
124	····PersistenceManager pm;
125	····NDOMapping mapping;
126	····Class ownClass;
127	····Class otherClass;
128	····[SetUp]
129	····public void Setup()
130	····{
131	········this.pm = PmFactory.NewPersistenceManager();
132	········this.mapping = pm.NDOMapping;
133	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11NoTblAutoLeft" );
134	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11NoTblAutoRight" );
135	····}
136	····[Test]
137	····public void HasMappingTable()
138	····{
139	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
140	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
141	····}
142	····[Test]
143	····public void HasTypeColumn()
144	····{
145	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
146	····}
147	····[Test]
148	····public void HasTypeCode()
149	····{
150	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
151	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
152	····}
153	}
154
155
156	[TestFixture]
157	public class MappingTestAgrBi11TblAuto
158	{
159	····PersistenceManager pm;
160	····NDOMapping mapping;
161	····Class ownClass;
162	····Class otherClass;
163	····[SetUp]
164	····public void Setup()
165	····{
166	········this.pm = PmFactory.NewPersistenceManager();
167	········this.mapping = pm.NDOMapping;
168	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11TblAutoLeft" );
169	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11TblAutoRight" );
170	····}
171	····[Test]
172	····public void HasMappingTable()
173	····{
174	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
175	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
176	····}
177	····[Test]
178	····public void HasTypeColumn()
179	····{
180	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
181	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
182	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
183	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
184	····}
185	····[Test]
186	····public void HasTypeCode()
187	····{
188	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
189	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
190	····}
191	}
192
193
194	[TestFixture]
195	public class MappingTestAgrDirnNoTblAuto
196	{
197	····PersistenceManager pm;
198	····NDOMapping mapping;
199	····Class ownClass;
200	····Class otherClass;
201	····[SetUp]
202	····public void Setup()
203	····{
204	········this.pm = PmFactory.NewPersistenceManager();
205	········this.mapping = pm.NDOMapping;
206	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnNoTblAutoLeft" );
207	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnNoTblAutoRight" );
208	····}
209	····[Test]
210	····public void HasMappingTable()
211	····{
212	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
213	····}
214	····[Test]
215	····public void HasTypeColumn()
216	····{
217	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
218	····}
219	····[Test]
220	····public void HasTypeCode()
221	····{
222	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
223	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
224	····}
225	}
226
227
228	[TestFixture]
229	public class MappingTestAgrDirnTblAuto
230	{
231	····PersistenceManager pm;
232	····NDOMapping mapping;
233	····Class ownClass;
234	····Class otherClass;
235	····[SetUp]
236	····public void Setup()
237	····{
238	········this.pm = PmFactory.NewPersistenceManager();
239	········this.mapping = pm.NDOMapping;
240	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnTblAutoLeft" );
241	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnTblAutoRight" );
242	····}
243	····[Test]
244	····public void HasMappingTable()
245	····{
246	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
247	····}
248	····[Test]
249	····public void HasTypeColumn()
250	····{
251	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
252	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
253	····}
254	····[Test]
255	····public void HasTypeCode()
256	····{
257	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
258	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
259	····}
260	}
261
262
263	[TestFixture]
264	public class MappingTestAgrBin1NoTblAuto
265	{
266	····PersistenceManager pm;
267	····NDOMapping mapping;
268	····Class ownClass;
269	····Class otherClass;
270	····[SetUp]
271	····public void Setup()
272	····{
273	········this.pm = PmFactory.NewPersistenceManager();
274	········this.mapping = pm.NDOMapping;
275	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1NoTblAutoLeft" );
276	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1NoTblAutoRight" );
277	····}
278	····[Test]
279	····public void HasMappingTable()
280	····{
281	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
282	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
283	····}
284	····[Test]
285	····public void HasTypeColumn()
286	····{
287	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
288	····}
289	····[Test]
290	····public void HasTypeCode()
291	····{
292	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
293	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
294	····}
295	}
296
297
298	[TestFixture]
299	public class MappingTestAgrBin1TblAuto
300	{
301	····PersistenceManager pm;
302	····NDOMapping mapping;
303	····Class ownClass;
304	····Class otherClass;
305	····[SetUp]
306	····public void Setup()
307	····{
308	········this.pm = PmFactory.NewPersistenceManager();
309	········this.mapping = pm.NDOMapping;
310	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1TblAutoLeft" );
311	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1TblAutoRight" );
312	····}
313	····[Test]
314	····public void HasMappingTable()
315	····{
316	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
317	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
318	····}
319	····[Test]
320	····public void HasTypeColumn()
321	····{
322	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
323	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
324	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
325	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
326	····}
327	····[Test]
328	····public void HasTypeCode()
329	····{
330	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
331	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
332	····}
333	}
334
335
336	[TestFixture]
337	public class MappingTestAgrBi1nNoTblAuto
338	{
339	····PersistenceManager pm;
340	····NDOMapping mapping;
341	····Class ownClass;
342	····Class otherClass;
343	····[SetUp]
344	····public void Setup()
345	····{
346	········this.pm = PmFactory.NewPersistenceManager();
347	········this.mapping = pm.NDOMapping;
348	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nNoTblAutoLeft" );
349	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nNoTblAutoRight" );
350	····}
351	····[Test]
352	····public void HasMappingTable()
353	····{
354	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
355	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
356	····}
357	····[Test]
358	····public void HasTypeColumn()
359	····{
360	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
361	····}
362	····[Test]
363	····public void HasTypeCode()
364	····{
365	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
366	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
367	····}
368	}
369
370
371	[TestFixture]
372	public class MappingTestAgrBi1nTblAuto
373	{
374	····PersistenceManager pm;
375	····NDOMapping mapping;
376	····Class ownClass;
377	····Class otherClass;
378	····[SetUp]
379	····public void Setup()
380	····{
381	········this.pm = PmFactory.NewPersistenceManager();
382	········this.mapping = pm.NDOMapping;
383	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nTblAutoLeft" );
384	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nTblAutoRight" );
385	····}
386	····[Test]
387	····public void HasMappingTable()
388	····{
389	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
390	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
391	····}
392	····[Test]
393	····public void HasTypeColumn()
394	····{
395	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
396	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
397	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
398	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
399	····}
400	····[Test]
401	····public void HasTypeCode()
402	····{
403	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
404	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
405	····}
406	}
407
408
409	[TestFixture]
410	public class MappingTestAgrBinnTblAuto
411	{
412	····PersistenceManager pm;
413	····NDOMapping mapping;
414	····Class ownClass;
415	····Class otherClass;
416	····[SetUp]
417	····public void Setup()
418	····{
419	········this.pm = PmFactory.NewPersistenceManager();
420	········this.mapping = pm.NDOMapping;
421	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnTblAutoLeft" );
422	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnTblAutoRight" );
423	····}
424	····[Test]
425	····public void HasMappingTable()
426	····{
427	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
428	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
429	····}
430	····[Test]
431	····public void HasTypeColumn()
432	····{
433	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
434	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
435	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
436	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
437	····}
438	····[Test]
439	····public void HasTypeCode()
440	····{
441	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
442	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
443	····}
444	}
445
446
447	[TestFixture]
448	public class MappingTestCmpDir1NoTblAuto
449	{
450	····PersistenceManager pm;
451	····NDOMapping mapping;
452	····Class ownClass;
453	····Class otherClass;
454	····[SetUp]
455	····public void Setup()
456	····{
457	········this.pm = PmFactory.NewPersistenceManager();
458	········this.mapping = pm.NDOMapping;
459	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1NoTblAutoLeft" );
460	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1NoTblAutoRight" );
461	····}
462	····[Test]
463	····public void HasMappingTable()
464	····{
465	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
466	····}
467	····[Test]
468	····public void HasTypeColumn()
469	····{
470	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
471	····}
472	····[Test]
473	····public void HasTypeCode()
474	····{
475	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
476	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
477	····}
478	}
479
480
481	[TestFixture]
482	public class MappingTestCmpDir1TblAuto
483	{
484	····PersistenceManager pm;
485	····NDOMapping mapping;
486	····Class ownClass;
487	····Class otherClass;
488	····[SetUp]
489	····public void Setup()
490	····{
491	········this.pm = PmFactory.NewPersistenceManager();
492	········this.mapping = pm.NDOMapping;
493	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1TblAutoLeft" );
494	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1TblAutoRight" );
495	····}
496	····[Test]
497	····public void HasMappingTable()
498	····{
499	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
500	····}
501	····[Test]
502	····public void HasTypeColumn()
503	····{
504	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
505	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
506	····}
507	····[Test]
508	····public void HasTypeCode()
509	····{
510	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
511	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
512	····}
513	}
514
515
516	[TestFixture]
517	public class MappingTestCmpBi11NoTblAuto
518	{
519	····PersistenceManager pm;
520	····NDOMapping mapping;
521	····Class ownClass;
522	····Class otherClass;
523	····[SetUp]
524	····public void Setup()
525	····{
526	········this.pm = PmFactory.NewPersistenceManager();
527	········this.mapping = pm.NDOMapping;
528	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11NoTblAutoLeft" );
529	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11NoTblAutoRight" );
530	····}
531	····[Test]
532	····public void HasMappingTable()
533	····{
534	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
535	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
536	····}
537	····[Test]
538	····public void HasTypeColumn()
539	····{
540	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
541	····}
542	····[Test]
543	····public void HasTypeCode()
544	····{
545	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
546	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
547	····}
548	}
549
550
551	[TestFixture]
552	public class MappingTestCmpBi11TblAuto
553	{
554	····PersistenceManager pm;
555	····NDOMapping mapping;
556	····Class ownClass;
557	····Class otherClass;
558	····[SetUp]
559	····public void Setup()
560	····{
561	········this.pm = PmFactory.NewPersistenceManager();
562	········this.mapping = pm.NDOMapping;
563	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11TblAutoLeft" );
564	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11TblAutoRight" );
565	····}
566	····[Test]
567	····public void HasMappingTable()
568	····{
569	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
570	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
571	····}
572	····[Test]
573	····public void HasTypeColumn()
574	····{
575	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
576	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
577	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
578	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
579	····}
580	····[Test]
581	····public void HasTypeCode()
582	····{
583	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
584	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
585	····}
586	}
587
588
589	[TestFixture]
590	public class MappingTestCmpDirnNoTblAuto
591	{
592	····PersistenceManager pm;
593	····NDOMapping mapping;
594	····Class ownClass;
595	····Class otherClass;
596	····[SetUp]
597	····public void Setup()
598	····{
599	········this.pm = PmFactory.NewPersistenceManager();
600	········this.mapping = pm.NDOMapping;
601	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnNoTblAutoLeft" );
602	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnNoTblAutoRight" );
603	····}
604	····[Test]
605	····public void HasMappingTable()
606	····{
607	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
608	····}
609	····[Test]
610	····public void HasTypeColumn()
611	····{
612	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
613	····}
614	····[Test]
615	····public void HasTypeCode()
616	····{
617	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
618	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
619	····}
620	}
621
622
623	[TestFixture]
624	public class MappingTestCmpDirnTblAuto
625	{
626	····PersistenceManager pm;
627	····NDOMapping mapping;
628	····Class ownClass;
629	····Class otherClass;
630	····[SetUp]
631	····public void Setup()
632	····{
633	········this.pm = PmFactory.NewPersistenceManager();
634	········this.mapping = pm.NDOMapping;
635	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnTblAutoLeft" );
636	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnTblAutoRight" );
637	····}
638	····[Test]
639	····public void HasMappingTable()
640	····{
641	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
642	····}
643	····[Test]
644	····public void HasTypeColumn()
645	····{
646	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
647	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
648	····}
649	····[Test]
650	····public void HasTypeCode()
651	····{
652	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
653	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
654	····}
655	}
656
657
658	[TestFixture]
659	public class MappingTestCmpBin1NoTblAuto
660	{
661	····PersistenceManager pm;
662	····NDOMapping mapping;
663	····Class ownClass;
664	····Class otherClass;
665	····[SetUp]
666	····public void Setup()
667	····{
668	········this.pm = PmFactory.NewPersistenceManager();
669	········this.mapping = pm.NDOMapping;
670	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1NoTblAutoLeft" );
671	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1NoTblAutoRight" );
672	····}
673	····[Test]
674	····public void HasMappingTable()
675	····{
676	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
677	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
678	····}
679	····[Test]
680	····public void HasTypeColumn()
681	····{
682	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
683	····}
684	····[Test]
685	····public void HasTypeCode()
686	····{
687	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
688	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
689	····}
690	}
691
692
693	[TestFixture]
694	public class MappingTestCmpBin1TblAuto
695	{
696	····PersistenceManager pm;
697	····NDOMapping mapping;
698	····Class ownClass;
699	····Class otherClass;
700	····[SetUp]
701	····public void Setup()
702	····{
703	········this.pm = PmFactory.NewPersistenceManager();
704	········this.mapping = pm.NDOMapping;
705	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1TblAutoLeft" );
706	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1TblAutoRight" );
707	····}
708	····[Test]
709	····public void HasMappingTable()
710	····{
711	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
712	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
713	····}
714	····[Test]
715	····public void HasTypeColumn()
716	····{
717	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
718	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
719	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
720	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
721	····}
722	····[Test]
723	····public void HasTypeCode()
724	····{
725	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
726	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
727	····}
728	}
729
730
731	[TestFixture]
732	public class MappingTestCmpBi1nNoTblAuto
733	{
734	····PersistenceManager pm;
735	····NDOMapping mapping;
736	····Class ownClass;
737	····Class otherClass;
738	····[SetUp]
739	····public void Setup()
740	····{
741	········this.pm = PmFactory.NewPersistenceManager();
742	········this.mapping = pm.NDOMapping;
743	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nNoTblAutoLeft" );
744	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nNoTblAutoRight" );
745	····}
746	····[Test]
747	····public void HasMappingTable()
748	····{
749	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
750	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
751	····}
752	····[Test]
753	····public void HasTypeColumn()
754	····{
755	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
756	····}
757	····[Test]
758	····public void HasTypeCode()
759	····{
760	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
761	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
762	····}
763	}
764
765
766	[TestFixture]
767	public class MappingTestCmpBi1nTblAuto
768	{
769	····PersistenceManager pm;
770	····NDOMapping mapping;
771	····Class ownClass;
772	····Class otherClass;
773	····[SetUp]
774	····public void Setup()
775	····{
776	········this.pm = PmFactory.NewPersistenceManager();
777	········this.mapping = pm.NDOMapping;
778	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nTblAutoLeft" );
779	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nTblAutoRight" );
780	····}
781	····[Test]
782	····public void HasMappingTable()
783	····{
784	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
785	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
786	····}
787	····[Test]
788	····public void HasTypeColumn()
789	····{
790	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
791	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
792	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
793	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
794	····}
795	····[Test]
796	····public void HasTypeCode()
797	····{
798	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
799	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
800	····}
801	}
802
803
804	[TestFixture]
805	public class MappingTestCmpBinnTblAuto
806	{
807	····PersistenceManager pm;
808	····NDOMapping mapping;
809	····Class ownClass;
810	····Class otherClass;
811	····[SetUp]
812	····public void Setup()
813	····{
814	········this.pm = PmFactory.NewPersistenceManager();
815	········this.mapping = pm.NDOMapping;
816	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnTblAutoLeft" );
817	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnTblAutoRight" );
818	····}
819	····[Test]
820	····public void HasMappingTable()
821	····{
822	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
823	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
824	····}
825	····[Test]
826	····public void HasTypeColumn()
827	····{
828	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
829	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
830	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
831	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
832	····}
833	····[Test]
834	····public void HasTypeCode()
835	····{
836	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
837	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
838	····}
839	}
840
841
842	[TestFixture]
843	public class MappingTestAgrDir1OwnpconNoTblAuto
844	{
845	····PersistenceManager pm;
846	····NDOMapping mapping;
847	····Class ownClass;
848	····Class otherClass;
849	····Class ownDerivedClass;
850	····[SetUp]
851	····public void Setup()
852	····{
853	········this.pm = PmFactory.NewPersistenceManager();
854	········this.mapping = pm.NDOMapping;
855	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconNoTblAutoLeftBase" );
856	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconNoTblAutoRight" );
857	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconNoTblAutoLeftDerived" );
858	····}
859	····[Test]
860	····public void HasMappingTable()
861	····{
862	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
863	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
864	····}
865	····[Test]
866	····public void HasTypeColumn()
867	····{
868	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
869	····}
870	····[Test]
871	····public void HasTypeCode()
872	····{
873	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
874	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
875	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
876	····}
877	}
878
879
880	[TestFixture]
881	public class MappingTestAgrDir1OwnpconTblAuto
882	{
883	····PersistenceManager pm;
884	····NDOMapping mapping;
885	····Class ownClass;
886	····Class otherClass;
887	····Class ownDerivedClass;
888	····[SetUp]
889	····public void Setup()
890	····{
891	········this.pm = PmFactory.NewPersistenceManager();
892	········this.mapping = pm.NDOMapping;
893	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconTblAutoLeftBase" );
894	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconTblAutoRight" );
895	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconTblAutoLeftDerived" );
896	····}
897	····[Test]
898	····public void HasMappingTable()
899	····{
900	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
901	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
902	····}
903	····[Test]
904	····public void HasTypeColumn()
905	····{
906	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
907	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
908	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
909	····}
910	····[Test]
911	····public void HasTypeCode()
912	····{
913	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
914	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
915	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
916	····}
917	}
918
919
920	[TestFixture]
921	public class MappingTestAgrBi11OwnpconNoTblAuto
922	{
923	····PersistenceManager pm;
924	····NDOMapping mapping;
925	····Class ownClass;
926	····Class otherClass;
927	····Class ownDerivedClass;
928	····[SetUp]
929	····public void Setup()
930	····{
931	········this.pm = PmFactory.NewPersistenceManager();
932	········this.mapping = pm.NDOMapping;
933	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconNoTblAutoLeftBase" );
934	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconNoTblAutoRight" );
935	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconNoTblAutoLeftDerived" );
936	····}
937	····[Test]
938	····public void HasMappingTable()
939	····{
940	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
941	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
942	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
943	····}
944	····[Test]
945	····public void HasTypeColumn()
946	····{
947	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
948	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #10") ;
949	····}
950	····[Test]
951	····public void HasTypeCode()
952	····{
953	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
954	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
955	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
956	····}
957	}
958
959
960	[TestFixture]
961	public class MappingTestAgrBi11OwnpconTblAuto
962	{
963	····PersistenceManager pm;
964	····NDOMapping mapping;
965	····Class ownClass;
966	····Class otherClass;
967	····Class ownDerivedClass;
968	····[SetUp]
969	····public void Setup()
970	····{
971	········this.pm = PmFactory.NewPersistenceManager();
972	········this.mapping = pm.NDOMapping;
973	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconTblAutoLeftBase" );
974	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconTblAutoRight" );
975	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconTblAutoLeftDerived" );
976	····}
977	····[Test]
978	····public void HasMappingTable()
979	····{
980	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
981	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
982	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
983	····}
984	····[Test]
985	····public void HasTypeColumn()
986	····{
987	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
988	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
989	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
990	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
991	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
992	····}
993	····[Test]
994	····public void HasTypeCode()
995	····{
996	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
997	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
998	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
999	····}
1000	}
1001
1002
1003	[TestFixture]
1004	public class MappingTestAgrDirnOwnpconNoTblAuto
1005	{
1006	····PersistenceManager pm;
1007	····NDOMapping mapping;
1008	····Class ownClass;
1009	····Class otherClass;
1010	····Class ownDerivedClass;
1011	····[SetUp]
1012	····public void Setup()
1013	····{
1014	········this.pm = PmFactory.NewPersistenceManager();
1015	········this.mapping = pm.NDOMapping;
1016	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconNoTblAutoLeftBase" );
1017	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconNoTblAutoRight" );
1018	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconNoTblAutoLeftDerived" );
1019	····}
1020	····[Test]
1021	····public void HasMappingTable()
1022	····{
1023	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
1024	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
1025	····}
1026	····[Test]
1027	····public void HasTypeColumn()
1028	····{
1029	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
1030	····}
1031	····[Test]
1032	····public void HasTypeCode()
1033	····{
1034	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1035	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1036	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1037	····}
1038	}
1039
1040
1041	[TestFixture]
1042	public class MappingTestAgrDirnOwnpconTblAuto
1043	{
1044	····PersistenceManager pm;
1045	····NDOMapping mapping;
1046	····Class ownClass;
1047	····Class otherClass;
1048	····Class ownDerivedClass;
1049	····[SetUp]
1050	····public void Setup()
1051	····{
1052	········this.pm = PmFactory.NewPersistenceManager();
1053	········this.mapping = pm.NDOMapping;
1054	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconTblAutoLeftBase" );
1055	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconTblAutoRight" );
1056	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconTblAutoLeftDerived" );
1057	····}
1058	····[Test]
1059	····public void HasMappingTable()
1060	····{
1061	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
1062	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
1063	····}
1064	····[Test]
1065	····public void HasTypeColumn()
1066	····{
1067	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
1068	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
1069	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
1070	····}
1071	····[Test]
1072	····public void HasTypeCode()
1073	····{
1074	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1075	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1076	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1077	····}
1078	}
1079
1080
1081	[TestFixture]
1082	public class MappingTestAgrBin1OwnpconNoTblAuto
1083	{
1084	····PersistenceManager pm;
1085	····NDOMapping mapping;
1086	····Class ownClass;
1087	····Class otherClass;
1088	····Class ownDerivedClass;
1089	····[SetUp]
1090	····public void Setup()
1091	····{
1092	········this.pm = PmFactory.NewPersistenceManager();
1093	········this.mapping = pm.NDOMapping;
1094	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconNoTblAutoLeftBase" );
1095	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconNoTblAutoRight" );
1096	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconNoTblAutoLeftDerived" );
1097	····}
1098	····[Test]
1099	····public void HasMappingTable()
1100	····{
1101	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
1102	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
1103	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
1104	····}
1105	····[Test]
1106	····public void HasTypeColumn()
1107	····{
1108	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
1109	····}
1110	····[Test]
1111	····public void HasTypeCode()
1112	····{
1113	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1114	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1115	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1116	····}
1117	}
1118
1119
1120	[TestFixture]
1121	public class MappingTestAgrBin1OwnpconTblAuto
1122	{
1123	····PersistenceManager pm;
1124	····NDOMapping mapping;
1125	····Class ownClass;
1126	····Class otherClass;
1127	····Class ownDerivedClass;
1128	····[SetUp]
1129	····public void Setup()
1130	····{
1131	········this.pm = PmFactory.NewPersistenceManager();
1132	········this.mapping = pm.NDOMapping;
1133	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconTblAutoLeftBase" );
1134	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconTblAutoRight" );
1135	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconTblAutoLeftDerived" );
1136	····}
1137	····[Test]
1138	····public void HasMappingTable()
1139	····{
1140	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
1141	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
1142	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
1143	····}
1144	····[Test]
1145	····public void HasTypeColumn()
1146	····{
1147	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
1148	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
1149	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
1150	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
1151	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
1152	····}
1153	····[Test]
1154	····public void HasTypeCode()
1155	····{
1156	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1157	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1158	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1159	····}
1160	}
1161
1162
1163	[TestFixture]
1164	public class MappingTestAgrBi1nOwnpconTblAuto
1165	{
1166	····PersistenceManager pm;
1167	····NDOMapping mapping;
1168	····Class ownClass;
1169	····Class otherClass;
1170	····Class ownDerivedClass;
1171	····[SetUp]
1172	····public void Setup()
1173	····{
1174	········this.pm = PmFactory.NewPersistenceManager();
1175	········this.mapping = pm.NDOMapping;
1176	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconTblAutoLeftBase" );
1177	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconTblAutoRight" );
1178	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconTblAutoLeftDerived" );
1179	····}
1180	····[Test]
1181	····public void HasMappingTable()
1182	····{
1183	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
1184	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
1185	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
1186	····}
1187	····[Test]
1188	····public void HasTypeColumn()
1189	····{
1190	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
1191	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
1192	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
1193	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
1194	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
1195	····}
1196	····[Test]
1197	····public void HasTypeCode()
1198	····{
1199	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1200	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1201	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1202	····}
1203	}
1204
1205
1206	[TestFixture]
1207	public class MappingTestAgrBinnOwnpconTblAuto
1208	{
1209	····PersistenceManager pm;
1210	····NDOMapping mapping;
1211	····Class ownClass;
1212	····Class otherClass;
1213	····Class ownDerivedClass;
1214	····[SetUp]
1215	····public void Setup()
1216	····{
1217	········this.pm = PmFactory.NewPersistenceManager();
1218	········this.mapping = pm.NDOMapping;
1219	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconTblAutoLeftBase" );
1220	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconTblAutoRight" );
1221	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconTblAutoLeftDerived" );
1222	····}
1223	····[Test]
1224	····public void HasMappingTable()
1225	····{
1226	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
1227	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
1228	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
1229	····}
1230	····[Test]
1231	····public void HasTypeColumn()
1232	····{
1233	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
1234	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
1235	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
1236	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
1237	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
1238	····}
1239	····[Test]
1240	····public void HasTypeCode()
1241	····{
1242	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1243	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1244	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1245	····}
1246	}
1247
1248
1249	[TestFixture]
1250	public class MappingTestCmpDir1OwnpconNoTblAuto
1251	{
1252	····PersistenceManager pm;
1253	····NDOMapping mapping;
1254	····Class ownClass;
1255	····Class otherClass;
1256	····Class ownDerivedClass;
1257	····[SetUp]
1258	····public void Setup()
1259	····{
1260	········this.pm = PmFactory.NewPersistenceManager();
1261	········this.mapping = pm.NDOMapping;
1262	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconNoTblAutoLeftBase" );
1263	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconNoTblAutoRight" );
1264	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconNoTblAutoLeftDerived" );
1265	····}
1266	····[Test]
1267	····public void HasMappingTable()
1268	····{
1269	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
1270	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
1271	····}
1272	····[Test]
1273	····public void HasTypeColumn()
1274	····{
1275	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
1276	····}
1277	····[Test]
1278	····public void HasTypeCode()
1279	····{
1280	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1281	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1282	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1283	····}
1284	}
1285
1286
1287	[TestFixture]
1288	public class MappingTestCmpDir1OwnpconTblAuto
1289	{
1290	····PersistenceManager pm;
1291	····NDOMapping mapping;
1292	····Class ownClass;
1293	····Class otherClass;
1294	····Class ownDerivedClass;
1295	····[SetUp]
1296	····public void Setup()
1297	····{
1298	········this.pm = PmFactory.NewPersistenceManager();
1299	········this.mapping = pm.NDOMapping;
1300	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconTblAutoLeftBase" );
1301	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconTblAutoRight" );
1302	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconTblAutoLeftDerived" );
1303	····}
1304	····[Test]
1305	····public void HasMappingTable()
1306	····{
1307	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
1308	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
1309	····}
1310	····[Test]
1311	····public void HasTypeColumn()
1312	····{
1313	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
1314	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
1315	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
1316	····}
1317	····[Test]
1318	····public void HasTypeCode()
1319	····{
1320	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1321	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1322	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1323	····}
1324	}
1325
1326
1327	[TestFixture]
1328	public class MappingTestCmpBi11OwnpconNoTblAuto
1329	{
1330	····PersistenceManager pm;
1331	····NDOMapping mapping;
1332	····Class ownClass;
1333	····Class otherClass;
1334	····Class ownDerivedClass;
1335	····[SetUp]
1336	····public void Setup()
1337	····{
1338	········this.pm = PmFactory.NewPersistenceManager();
1339	········this.mapping = pm.NDOMapping;
1340	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconNoTblAutoLeftBase" );
1341	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconNoTblAutoRight" );
1342	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconNoTblAutoLeftDerived" );
1343	····}
1344	····[Test]
1345	····public void HasMappingTable()
1346	····{
1347	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
1348	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
1349	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
1350	····}
1351	····[Test]
1352	····public void HasTypeColumn()
1353	····{
1354	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
1355	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #10") ;
1356	····}
1357	····[Test]
1358	····public void HasTypeCode()
1359	····{
1360	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1361	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1362	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1363	····}
1364	}
1365
1366
1367	[TestFixture]
1368	public class MappingTestCmpBi11OwnpconTblAuto
1369	{
1370	····PersistenceManager pm;
1371	····NDOMapping mapping;
1372	····Class ownClass;
1373	····Class otherClass;
1374	····Class ownDerivedClass;
1375	····[SetUp]
1376	····public void Setup()
1377	····{
1378	········this.pm = PmFactory.NewPersistenceManager();
1379	········this.mapping = pm.NDOMapping;
1380	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconTblAutoLeftBase" );
1381	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconTblAutoRight" );
1382	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconTblAutoLeftDerived" );
1383	····}
1384	····[Test]
1385	····public void HasMappingTable()
1386	····{
1387	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
1388	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
1389	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
1390	····}
1391	····[Test]
1392	····public void HasTypeColumn()
1393	····{
1394	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
1395	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
1396	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
1397	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
1398	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
1399	····}
1400	····[Test]
1401	····public void HasTypeCode()
1402	····{
1403	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1404	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1405	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1406	····}
1407	}
1408
1409
1410	[TestFixture]
1411	public class MappingTestCmpDirnOwnpconNoTblAuto
1412	{
1413	····PersistenceManager pm;
1414	····NDOMapping mapping;
1415	····Class ownClass;
1416	····Class otherClass;
1417	····Class ownDerivedClass;
1418	····[SetUp]
1419	····public void Setup()
1420	····{
1421	········this.pm = PmFactory.NewPersistenceManager();
1422	········this.mapping = pm.NDOMapping;
1423	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconNoTblAutoLeftBase" );
1424	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconNoTblAutoRight" );
1425	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconNoTblAutoLeftDerived" );
1426	····}
1427	····[Test]
1428	····public void HasMappingTable()
1429	····{
1430	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
1431	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
1432	····}
1433	····[Test]
1434	····public void HasTypeColumn()
1435	····{
1436	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
1437	····}
1438	····[Test]
1439	····public void HasTypeCode()
1440	····{
1441	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1442	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1443	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1444	····}
1445	}
1446
1447
1448	[TestFixture]
1449	public class MappingTestCmpDirnOwnpconTblAuto
1450	{
1451	····PersistenceManager pm;
1452	····NDOMapping mapping;
1453	····Class ownClass;
1454	····Class otherClass;
1455	····Class ownDerivedClass;
1456	····[SetUp]
1457	····public void Setup()
1458	····{
1459	········this.pm = PmFactory.NewPersistenceManager();
1460	········this.mapping = pm.NDOMapping;
1461	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconTblAutoLeftBase" );
1462	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconTblAutoRight" );
1463	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconTblAutoLeftDerived" );
1464	····}
1465	····[Test]
1466	····public void HasMappingTable()
1467	····{
1468	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
1469	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
1470	····}
1471	····[Test]
1472	····public void HasTypeColumn()
1473	····{
1474	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
1475	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
1476	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
1477	····}
1478	····[Test]
1479	····public void HasTypeCode()
1480	····{
1481	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1482	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1483	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1484	····}
1485	}
1486
1487
1488	[TestFixture]
1489	public class MappingTestCmpBin1OwnpconNoTblAuto
1490	{
1491	····PersistenceManager pm;
1492	····NDOMapping mapping;
1493	····Class ownClass;
1494	····Class otherClass;
1495	····Class ownDerivedClass;
1496	····[SetUp]
1497	····public void Setup()
1498	····{
1499	········this.pm = PmFactory.NewPersistenceManager();
1500	········this.mapping = pm.NDOMapping;
1501	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconNoTblAutoLeftBase" );
1502	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconNoTblAutoRight" );
1503	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconNoTblAutoLeftDerived" );
1504	····}
1505	····[Test]
1506	····public void HasMappingTable()
1507	····{
1508	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
1509	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
1510	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
1511	····}
1512	····[Test]
1513	····public void HasTypeColumn()
1514	····{
1515	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
1516	····}
1517	····[Test]
1518	····public void HasTypeCode()
1519	····{
1520	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1521	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1522	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1523	····}
1524	}
1525
1526
1527	[TestFixture]
1528	public class MappingTestCmpBin1OwnpconTblAuto
1529	{
1530	····PersistenceManager pm;
1531	····NDOMapping mapping;
1532	····Class ownClass;
1533	····Class otherClass;
1534	····Class ownDerivedClass;
1535	····[SetUp]
1536	····public void Setup()
1537	····{
1538	········this.pm = PmFactory.NewPersistenceManager();
1539	········this.mapping = pm.NDOMapping;
1540	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconTblAutoLeftBase" );
1541	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconTblAutoRight" );
1542	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconTblAutoLeftDerived" );
1543	····}
1544	····[Test]
1545	····public void HasMappingTable()
1546	····{
1547	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
1548	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
1549	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
1550	····}
1551	····[Test]
1552	····public void HasTypeColumn()
1553	····{
1554	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
1555	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
1556	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
1557	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
1558	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
1559	····}
1560	····[Test]
1561	····public void HasTypeCode()
1562	····{
1563	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1564	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1565	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1566	····}
1567	}
1568
1569
1570	[TestFixture]
1571	public class MappingTestCmpBi1nOwnpconTblAuto
1572	{
1573	····PersistenceManager pm;
1574	····NDOMapping mapping;
1575	····Class ownClass;
1576	····Class otherClass;
1577	····Class ownDerivedClass;
1578	····[SetUp]
1579	····public void Setup()
1580	····{
1581	········this.pm = PmFactory.NewPersistenceManager();
1582	········this.mapping = pm.NDOMapping;
1583	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconTblAutoLeftBase" );
1584	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconTblAutoRight" );
1585	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconTblAutoLeftDerived" );
1586	····}
1587	····[Test]
1588	····public void HasMappingTable()
1589	····{
1590	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
1591	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
1592	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
1593	····}
1594	····[Test]
1595	····public void HasTypeColumn()
1596	····{
1597	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
1598	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
1599	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
1600	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
1601	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
1602	····}
1603	····[Test]
1604	····public void HasTypeCode()
1605	····{
1606	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1607	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1608	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1609	····}
1610	}
1611
1612
1613	[TestFixture]
1614	public class MappingTestCmpBinnOwnpconTblAuto
1615	{
1616	····PersistenceManager pm;
1617	····NDOMapping mapping;
1618	····Class ownClass;
1619	····Class otherClass;
1620	····Class ownDerivedClass;
1621	····[SetUp]
1622	····public void Setup()
1623	····{
1624	········this.pm = PmFactory.NewPersistenceManager();
1625	········this.mapping = pm.NDOMapping;
1626	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconTblAutoLeftBase" );
1627	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconTblAutoRight" );
1628	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconTblAutoLeftDerived" );
1629	····}
1630	····[Test]
1631	····public void HasMappingTable()
1632	····{
1633	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
1634	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
1635	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
1636	····}
1637	····[Test]
1638	····public void HasTypeColumn()
1639	····{
1640	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
1641	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
1642	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
1643	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
1644	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
1645	····}
1646	····[Test]
1647	····public void HasTypeCode()
1648	····{
1649	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1650	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1651	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1652	····}
1653	}
1654
1655
1656	[TestFixture]
1657	public class MappingTestAgrDir1OthpconNoTblAuto
1658	{
1659	····PersistenceManager pm;
1660	····NDOMapping mapping;
1661	····Class ownClass;
1662	····Class otherClass;
1663	····Class otherDerivedClass;
1664	····[SetUp]
1665	····public void Setup()
1666	····{
1667	········this.pm = PmFactory.NewPersistenceManager();
1668	········this.mapping = pm.NDOMapping;
1669	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconNoTblAutoLeft" );
1670	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconNoTblAutoRightBase" );
1671	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconNoTblAutoRightDerived" );
1672	····}
1673	····[Test]
1674	····public void HasMappingTable()
1675	····{
1676	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
1677	····}
1678	····[Test]
1679	····public void HasTypeColumn()
1680	····{
1681	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #9") ;
1682	····}
1683	····[Test]
1684	····public void HasTypeCode()
1685	····{
1686	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1687	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1688	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
1689	····}
1690	}
1691
1692
1693	[TestFixture]
1694	public class MappingTestAgrDir1OthpconTblAuto
1695	{
1696	····PersistenceManager pm;
1697	····NDOMapping mapping;
1698	····Class ownClass;
1699	····Class otherClass;
1700	····Class otherDerivedClass;
1701	····[SetUp]
1702	····public void Setup()
1703	····{
1704	········this.pm = PmFactory.NewPersistenceManager();
1705	········this.mapping = pm.NDOMapping;
1706	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconTblAutoLeft" );
1707	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconTblAutoRightBase" );
1708	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconTblAutoRightDerived" );
1709	····}
1710	····[Test]
1711	····public void HasMappingTable()
1712	····{
1713	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
1714	····}
1715	····[Test]
1716	····public void HasTypeColumn()
1717	····{
1718	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
1719	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
1720	····}
1721	····[Test]
1722	····public void HasTypeCode()
1723	····{
1724	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1725	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1726	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
1727	····}
1728	}
1729
1730
1731	[TestFixture]
1732	public class MappingTestAgrBi11OthpconNoTblAuto
1733	{
1734	····PersistenceManager pm;
1735	····NDOMapping mapping;
1736	····Class ownClass;
1737	····Class otherClass;
1738	····Class otherDerivedClass;
1739	····[SetUp]
1740	····public void Setup()
1741	····{
1742	········this.pm = PmFactory.NewPersistenceManager();
1743	········this.mapping = pm.NDOMapping;
1744	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconNoTblAutoLeft" );
1745	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconNoTblAutoRightBase" );
1746	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconNoTblAutoRightDerived" );
1747	····}
1748	····[Test]
1749	····public void HasMappingTable()
1750	····{
1751	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
1752	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
1753	Assert. Null( otherDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #8") ;
1754	····}
1755	····[Test]
1756	····public void HasTypeColumn()
1757	····{
1758	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #9") ;
1759	····}
1760	····[Test]
1761	····public void HasTypeCode()
1762	····{
1763	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1764	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1765	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
1766	····}
1767	}
1768
1769
1770	[TestFixture]
1771	public class MappingTestAgrBi11OthpconTblAuto
1772	{
1773	····PersistenceManager pm;
1774	····NDOMapping mapping;
1775	····Class ownClass;
1776	····Class otherClass;
1777	····Class otherDerivedClass;
1778	····[SetUp]
1779	····public void Setup()
1780	····{
1781	········this.pm = PmFactory.NewPersistenceManager();
1782	········this.mapping = pm.NDOMapping;
1783	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconTblAutoLeft" );
1784	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconTblAutoRightBase" );
1785	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconTblAutoRightDerived" );
1786	····}
1787	····[Test]
1788	····public void HasMappingTable()
1789	····{
1790	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
1791	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
1792	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
1793	····}
1794	····[Test]
1795	····public void HasTypeColumn()
1796	····{
1797	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
1798	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
1799	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
1800	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
1801	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
1802	····}
1803	····[Test]
1804	····public void HasTypeCode()
1805	····{
1806	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1807	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1808	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
1809	····}
1810	}
1811
1812
1813	[TestFixture]
1814	public class MappingTestAgrDirnOthpconTblAuto
1815	{
1816	····PersistenceManager pm;
1817	····NDOMapping mapping;
1818	····Class ownClass;
1819	····Class otherClass;
1820	····Class otherDerivedClass;
1821	····[SetUp]
1822	····public void Setup()
1823	····{
1824	········this.pm = PmFactory.NewPersistenceManager();
1825	········this.mapping = pm.NDOMapping;
1826	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpconTblAutoLeft" );
1827	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpconTblAutoRightBase" );
1828	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpconTblAutoRightDerived" );
1829	····}
1830	····[Test]
1831	····public void HasMappingTable()
1832	····{
1833	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
1834	····}
1835	····[Test]
1836	····public void HasTypeColumn()
1837	····{
1838	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
1839	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
1840	····}
1841	····[Test]
1842	····public void HasTypeCode()
1843	····{
1844	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1845	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1846	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
1847	····}
1848	}
1849
1850
1851	[TestFixture]
1852	public class MappingTestAgrBin1OthpconTblAuto
1853	{
1854	····PersistenceManager pm;
1855	····NDOMapping mapping;
1856	····Class ownClass;
1857	····Class otherClass;
1858	····Class otherDerivedClass;
1859	····[SetUp]
1860	····public void Setup()
1861	····{
1862	········this.pm = PmFactory.NewPersistenceManager();
1863	········this.mapping = pm.NDOMapping;
1864	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpconTblAutoLeft" );
1865	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpconTblAutoRightBase" );
1866	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpconTblAutoRightDerived" );
1867	····}
1868	····[Test]
1869	····public void HasMappingTable()
1870	····{
1871	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
1872	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
1873	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
1874	····}
1875	····[Test]
1876	····public void HasTypeColumn()
1877	····{
1878	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
1879	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
1880	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
1881	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
1882	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
1883	····}
1884	····[Test]
1885	····public void HasTypeCode()
1886	····{
1887	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1888	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1889	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
1890	····}
1891	}
1892
1893
1894	[TestFixture]
1895	public class MappingTestAgrBi1nOthpconNoTblAuto
1896	{
1897	····PersistenceManager pm;
1898	····NDOMapping mapping;
1899	····Class ownClass;
1900	····Class otherClass;
1901	····Class otherDerivedClass;
1902	····[SetUp]
1903	····public void Setup()
1904	····{
1905	········this.pm = PmFactory.NewPersistenceManager();
1906	········this.mapping = pm.NDOMapping;
1907	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconNoTblAutoLeft" );
1908	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconNoTblAutoRightBase" );
1909	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconNoTblAutoRightDerived" );
1910	····}
1911	····[Test]
1912	····public void HasMappingTable()
1913	····{
1914	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
1915	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
1916	Assert. Null( otherDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #8") ;
1917	····}
1918	····[Test]
1919	····public void HasTypeColumn()
1920	····{
1921	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #9") ;
1922	····}
1923	····[Test]
1924	····public void HasTypeCode()
1925	····{
1926	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1927	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1928	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
1929	····}
1930	}
1931
1932
1933	[TestFixture]
1934	public class MappingTestAgrBi1nOthpconTblAuto
1935	{
1936	····PersistenceManager pm;
1937	····NDOMapping mapping;
1938	····Class ownClass;
1939	····Class otherClass;
1940	····Class otherDerivedClass;
1941	····[SetUp]
1942	····public void Setup()
1943	····{
1944	········this.pm = PmFactory.NewPersistenceManager();
1945	········this.mapping = pm.NDOMapping;
1946	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconTblAutoLeft" );
1947	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconTblAutoRightBase" );
1948	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconTblAutoRightDerived" );
1949	····}
1950	····[Test]
1951	····public void HasMappingTable()
1952	····{
1953	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
1954	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
1955	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
1956	····}
1957	····[Test]
1958	····public void HasTypeColumn()
1959	····{
1960	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
1961	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
1962	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
1963	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
1964	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
1965	····}
1966	····[Test]
1967	····public void HasTypeCode()
1968	····{
1969	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1970	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1971	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
1972	····}
1973	}
1974
1975
1976	[TestFixture]
1977	public class MappingTestAgrBinnOthpconTblAuto
1978	{
1979	····PersistenceManager pm;
1980	····NDOMapping mapping;
1981	····Class ownClass;
1982	····Class otherClass;
1983	····Class otherDerivedClass;
1984	····[SetUp]
1985	····public void Setup()
1986	····{
1987	········this.pm = PmFactory.NewPersistenceManager();
1988	········this.mapping = pm.NDOMapping;
1989	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpconTblAutoLeft" );
1990	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpconTblAutoRightBase" );
1991	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpconTblAutoRightDerived" );
1992	····}
1993	····[Test]
1994	····public void HasMappingTable()
1995	····{
1996	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
1997	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
1998	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
1999	····}
2000	····[Test]
2001	····public void HasTypeColumn()
2002	····{
2003	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
2004	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
2005	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
2006	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
2007	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
2008	····}
2009	····[Test]
2010	····public void HasTypeCode()
2011	····{
2012	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2013	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2014	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2015	····}
2016	}
2017
2018
2019	[TestFixture]
2020	public class MappingTestCmpDir1OthpconTblAuto
2021	{
2022	····PersistenceManager pm;
2023	····NDOMapping mapping;
2024	····Class ownClass;
2025	····Class otherClass;
2026	····Class otherDerivedClass;
2027	····[SetUp]
2028	····public void Setup()
2029	····{
2030	········this.pm = PmFactory.NewPersistenceManager();
2031	········this.mapping = pm.NDOMapping;
2032	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconTblAutoLeft" );
2033	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconTblAutoRightBase" );
2034	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconTblAutoRightDerived" );
2035	····}
2036	····[Test]
2037	····public void HasMappingTable()
2038	····{
2039	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
2040	····}
2041	····[Test]
2042	····public void HasTypeColumn()
2043	····{
2044	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
2045	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
2046	····}
2047	····[Test]
2048	····public void HasTypeCode()
2049	····{
2050	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2051	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2052	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2053	····}
2054	}
2055
2056
2057	[TestFixture]
2058	public class MappingTestCmpBi11OthpconTblAuto
2059	{
2060	····PersistenceManager pm;
2061	····NDOMapping mapping;
2062	····Class ownClass;
2063	····Class otherClass;
2064	····Class otherDerivedClass;
2065	····[SetUp]
2066	····public void Setup()
2067	····{
2068	········this.pm = PmFactory.NewPersistenceManager();
2069	········this.mapping = pm.NDOMapping;
2070	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconTblAutoLeft" );
2071	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconTblAutoRightBase" );
2072	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconTblAutoRightDerived" );
2073	····}
2074	····[Test]
2075	····public void HasMappingTable()
2076	····{
2077	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
2078	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
2079	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
2080	····}
2081	····[Test]
2082	····public void HasTypeColumn()
2083	····{
2084	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
2085	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
2086	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
2087	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
2088	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
2089	····}
2090	····[Test]
2091	····public void HasTypeCode()
2092	····{
2093	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2094	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2095	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2096	····}
2097	}
2098
2099
2100	[TestFixture]
2101	public class MappingTestCmpDirnOthpconTblAuto
2102	{
2103	····PersistenceManager pm;
2104	····NDOMapping mapping;
2105	····Class ownClass;
2106	····Class otherClass;
2107	····Class otherDerivedClass;
2108	····[SetUp]
2109	····public void Setup()
2110	····{
2111	········this.pm = PmFactory.NewPersistenceManager();
2112	········this.mapping = pm.NDOMapping;
2113	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpconTblAutoLeft" );
2114	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpconTblAutoRightBase" );
2115	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpconTblAutoRightDerived" );
2116	····}
2117	····[Test]
2118	····public void HasMappingTable()
2119	····{
2120	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
2121	····}
2122	····[Test]
2123	····public void HasTypeColumn()
2124	····{
2125	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
2126	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
2127	····}
2128	····[Test]
2129	····public void HasTypeCode()
2130	····{
2131	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2132	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2133	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2134	····}
2135	}
2136
2137
2138	[TestFixture]
2139	public class MappingTestCmpBin1OthpconTblAuto
2140	{
2141	····PersistenceManager pm;
2142	····NDOMapping mapping;
2143	····Class ownClass;
2144	····Class otherClass;
2145	····Class otherDerivedClass;
2146	····[SetUp]
2147	····public void Setup()
2148	····{
2149	········this.pm = PmFactory.NewPersistenceManager();
2150	········this.mapping = pm.NDOMapping;
2151	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpconTblAutoLeft" );
2152	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpconTblAutoRightBase" );
2153	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpconTblAutoRightDerived" );
2154	····}
2155	····[Test]
2156	····public void HasMappingTable()
2157	····{
2158	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
2159	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
2160	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
2161	····}
2162	····[Test]
2163	····public void HasTypeColumn()
2164	····{
2165	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
2166	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
2167	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
2168	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
2169	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
2170	····}
2171	····[Test]
2172	····public void HasTypeCode()
2173	····{
2174	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2175	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2176	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2177	····}
2178	}
2179
2180
2181	[TestFixture]
2182	public class MappingTestCmpBi1nOthpconTblAuto
2183	{
2184	····PersistenceManager pm;
2185	····NDOMapping mapping;
2186	····Class ownClass;
2187	····Class otherClass;
2188	····Class otherDerivedClass;
2189	····[SetUp]
2190	····public void Setup()
2191	····{
2192	········this.pm = PmFactory.NewPersistenceManager();
2193	········this.mapping = pm.NDOMapping;
2194	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconTblAutoLeft" );
2195	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconTblAutoRightBase" );
2196	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconTblAutoRightDerived" );
2197	····}
2198	····[Test]
2199	····public void HasMappingTable()
2200	····{
2201	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
2202	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
2203	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
2204	····}
2205	····[Test]
2206	····public void HasTypeColumn()
2207	····{
2208	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
2209	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
2210	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
2211	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
2212	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
2213	····}
2214	····[Test]
2215	····public void HasTypeCode()
2216	····{
2217	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2218	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2219	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2220	····}
2221	}
2222
2223
2224	[TestFixture]
2225	public class MappingTestCmpBinnOthpconTblAuto
2226	{
2227	····PersistenceManager pm;
2228	····NDOMapping mapping;
2229	····Class ownClass;
2230	····Class otherClass;
2231	····Class otherDerivedClass;
2232	····[SetUp]
2233	····public void Setup()
2234	····{
2235	········this.pm = PmFactory.NewPersistenceManager();
2236	········this.mapping = pm.NDOMapping;
2237	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpconTblAutoLeft" );
2238	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpconTblAutoRightBase" );
2239	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpconTblAutoRightDerived" );
2240	····}
2241	····[Test]
2242	····public void HasMappingTable()
2243	····{
2244	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
2245	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
2246	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
2247	····}
2248	····[Test]
2249	····public void HasTypeColumn()
2250	····{
2251	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
2252	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
2253	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
2254	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
2255	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
2256	····}
2257	····[Test]
2258	····public void HasTypeCode()
2259	····{
2260	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2261	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2262	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2263	····}
2264	}
2265
2266
2267	[TestFixture]
2268	public class MappingTestAgrDir1OwnpconOthpconNoTblAuto
2269	{
2270	····PersistenceManager pm;
2271	····NDOMapping mapping;
2272	····Class ownClass;
2273	····Class otherClass;
2274	····Class ownDerivedClass;
2275	····Class otherDerivedClass;
2276	····[SetUp]
2277	····public void Setup()
2278	····{
2279	········this.pm = PmFactory.NewPersistenceManager();
2280	········this.mapping = pm.NDOMapping;
2281	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconNoTblAutoLeftBase" );
2282	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconNoTblAutoRightBase" );
2283	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconNoTblAutoLeftDerived" );
2284	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconNoTblAutoRightDerived" );
2285	····}
2286	····[Test]
2287	····public void HasMappingTable()
2288	····{
2289	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
2290	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
2291	····}
2292	····[Test]
2293	····public void HasTypeColumn()
2294	····{
2295	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #9") ;
2296	····}
2297	····[Test]
2298	····public void HasTypeCode()
2299	····{
2300	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2301	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2302	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2303	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2304	····}
2305	}
2306
2307
2308	[TestFixture]
2309	public class MappingTestAgrDir1OwnpconOthpconTblAuto
2310	{
2311	····PersistenceManager pm;
2312	····NDOMapping mapping;
2313	····Class ownClass;
2314	····Class otherClass;
2315	····Class ownDerivedClass;
2316	····Class otherDerivedClass;
2317	····[SetUp]
2318	····public void Setup()
2319	····{
2320	········this.pm = PmFactory.NewPersistenceManager();
2321	········this.mapping = pm.NDOMapping;
2322	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconTblAutoLeftBase" );
2323	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconTblAutoRightBase" );
2324	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconTblAutoLeftDerived" );
2325	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconTblAutoRightDerived" );
2326	····}
2327	····[Test]
2328	····public void HasMappingTable()
2329	····{
2330	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
2331	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
2332	····}
2333	····[Test]
2334	····public void HasTypeColumn()
2335	····{
2336	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
2337	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
2338	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
2339	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
2340	····}
2341	····[Test]
2342	····public void HasTypeCode()
2343	····{
2344	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2345	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2346	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2347	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2348	····}
2349	}
2350
2351
2352	[TestFixture]
2353	public class MappingTestAgrBi11OwnpconOthpconNoTblAuto
2354	{
2355	····PersistenceManager pm;
2356	····NDOMapping mapping;
2357	····Class ownClass;
2358	····Class otherClass;
2359	····Class ownDerivedClass;
2360	····Class otherDerivedClass;
2361	····[SetUp]
2362	····public void Setup()
2363	····{
2364	········this.pm = PmFactory.NewPersistenceManager();
2365	········this.mapping = pm.NDOMapping;
2366	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconNoTblAutoLeftBase" );
2367	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconNoTblAutoRightBase" );
2368	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconNoTblAutoLeftDerived" );
2369	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconNoTblAutoRightDerived" );
2370	····}
2371	····[Test]
2372	····public void HasMappingTable()
2373	····{
2374	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
2375	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
2376	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
2377	Assert. Null( otherDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #8") ;
2378	····}
2379	····[Test]
2380	····public void HasTypeColumn()
2381	····{
2382	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #9") ;
2383	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #10") ;
2384	····}
2385	····[Test]
2386	····public void HasTypeCode()
2387	····{
2388	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2389	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2390	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2391	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2392	····}
2393	}
2394
2395
2396	[TestFixture]
2397	public class MappingTestAgrBi11OwnpconOthpconTblAuto
2398	{
2399	····PersistenceManager pm;
2400	····NDOMapping mapping;
2401	····Class ownClass;
2402	····Class otherClass;
2403	····Class ownDerivedClass;
2404	····Class otherDerivedClass;
2405	····[SetUp]
2406	····public void Setup()
2407	····{
2408	········this.pm = PmFactory.NewPersistenceManager();
2409	········this.mapping = pm.NDOMapping;
2410	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconTblAutoLeftBase" );
2411	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconTblAutoRightBase" );
2412	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconTblAutoLeftDerived" );
2413	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconTblAutoRightDerived" );
2414	····}
2415	····[Test]
2416	····public void HasMappingTable()
2417	····{
2418	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
2419	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
2420	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
2421	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
2422	····}
2423	····[Test]
2424	····public void HasTypeColumn()
2425	····{
2426	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
2427	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
2428	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
2429	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
2430	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
2431	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
2432	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
2433	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #8") ;
2434	····}
2435	····[Test]
2436	····public void HasTypeCode()
2437	····{
2438	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2439	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2440	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2441	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2442	····}
2443	}
2444
2445
2446	[TestFixture]
2447	public class MappingTestAgrDirnOwnpconOthpconTblAuto
2448	{
2449	····PersistenceManager pm;
2450	····NDOMapping mapping;
2451	····Class ownClass;
2452	····Class otherClass;
2453	····Class ownDerivedClass;
2454	····Class otherDerivedClass;
2455	····[SetUp]
2456	····public void Setup()
2457	····{
2458	········this.pm = PmFactory.NewPersistenceManager();
2459	········this.mapping = pm.NDOMapping;
2460	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconOthpconTblAutoLeftBase" );
2461	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconOthpconTblAutoRightBase" );
2462	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconOthpconTblAutoLeftDerived" );
2463	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconOthpconTblAutoRightDerived" );
2464	····}
2465	····[Test]
2466	····public void HasMappingTable()
2467	····{
2468	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
2469	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
2470	····}
2471	····[Test]
2472	····public void HasTypeColumn()
2473	····{
2474	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
2475	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
2476	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
2477	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
2478	····}
2479	····[Test]
2480	····public void HasTypeCode()
2481	····{
2482	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2483	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2484	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2485	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2486	····}
2487	}
2488
2489
2490	[TestFixture]
2491	public class MappingTestAgrBin1OwnpconOthpconTblAuto
2492	{
2493	····PersistenceManager pm;
2494	····NDOMapping mapping;
2495	····Class ownClass;
2496	····Class otherClass;
2497	····Class ownDerivedClass;
2498	····Class otherDerivedClass;
2499	····[SetUp]
2500	····public void Setup()
2501	····{
2502	········this.pm = PmFactory.NewPersistenceManager();
2503	········this.mapping = pm.NDOMapping;
2504	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconOthpconTblAutoLeftBase" );
2505	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconOthpconTblAutoRightBase" );
2506	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconOthpconTblAutoLeftDerived" );
2507	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconOthpconTblAutoRightDerived" );
2508	····}
2509	····[Test]
2510	····public void HasMappingTable()
2511	····{
2512	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
2513	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
2514	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
2515	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
2516	····}
2517	····[Test]
2518	····public void HasTypeColumn()
2519	····{
2520	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
2521	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
2522	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
2523	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
2524	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
2525	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
2526	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
2527	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #8") ;
2528	····}
2529	····[Test]
2530	····public void HasTypeCode()
2531	····{
2532	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2533	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2534	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2535	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2536	····}
2537	}
2538
2539
2540	[TestFixture]
2541	public class MappingTestAgrBi1nOwnpconOthpconTblAuto
2542	{
2543	····PersistenceManager pm;
2544	····NDOMapping mapping;
2545	····Class ownClass;
2546	····Class otherClass;
2547	····Class ownDerivedClass;
2548	····Class otherDerivedClass;
2549	····[SetUp]
2550	····public void Setup()
2551	····{
2552	········this.pm = PmFactory.NewPersistenceManager();
2553	········this.mapping = pm.NDOMapping;
2554	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconOthpconTblAutoLeftBase" );
2555	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconOthpconTblAutoRightBase" );
2556	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconOthpconTblAutoLeftDerived" );
2557	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconOthpconTblAutoRightDerived" );
2558	····}
2559	····[Test]
2560	····public void HasMappingTable()
2561	····{
2562	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
2563	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
2564	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
2565	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
2566	····}
2567	····[Test]
2568	····public void HasTypeColumn()
2569	····{
2570	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
2571	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
2572	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
2573	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
2574	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
2575	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
2576	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
2577	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #8") ;
2578	····}
2579	····[Test]
2580	····public void HasTypeCode()
2581	····{
2582	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2583	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2584	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2585	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2586	····}
2587	}
2588
2589
2590	[TestFixture]
2591	public class MappingTestAgrBinnOwnpconOthpconTblAuto
2592	{
2593	····PersistenceManager pm;
2594	····NDOMapping mapping;
2595	····Class ownClass;
2596	····Class otherClass;
2597	····Class ownDerivedClass;
2598	····Class otherDerivedClass;
2599	····[SetUp]
2600	····public void Setup()
2601	····{
2602	········this.pm = PmFactory.NewPersistenceManager();
2603	········this.mapping = pm.NDOMapping;
2604	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconOthpconTblAutoLeftBase" );
2605	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconOthpconTblAutoRightBase" );
2606	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconOthpconTblAutoLeftDerived" );
2607	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconOthpconTblAutoRightDerived" );
2608	····}
2609	····[Test]
2610	····public void HasMappingTable()
2611	····{
2612	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
2613	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
2614	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
2615	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
2616	····}
2617	····[Test]
2618	····public void HasTypeColumn()
2619	····{
2620	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
2621	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
2622	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
2623	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
2624	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
2625	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
2626	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
2627	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #8") ;
2628	····}
2629	····[Test]
2630	····public void HasTypeCode()
2631	····{
2632	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2633	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2634	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2635	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2636	····}
2637	}
2638
2639
2640	[TestFixture]
2641	public class MappingTestCmpDir1OwnpconOthpconTblAuto
2642	{
2643	····PersistenceManager pm;
2644	····NDOMapping mapping;
2645	····Class ownClass;
2646	····Class otherClass;
2647	····Class ownDerivedClass;
2648	····Class otherDerivedClass;
2649	····[SetUp]
2650	····public void Setup()
2651	····{
2652	········this.pm = PmFactory.NewPersistenceManager();
2653	········this.mapping = pm.NDOMapping;
2654	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconTblAutoLeftBase" );
2655	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconTblAutoRightBase" );
2656	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconTblAutoLeftDerived" );
2657	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconTblAutoRightDerived" );
2658	····}
2659	····[Test]
2660	····public void HasMappingTable()
2661	····{
2662	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
2663	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
2664	····}
2665	····[Test]
2666	····public void HasTypeColumn()
2667	····{
2668	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
2669	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
2670	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
2671	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
2672	····}
2673	····[Test]
2674	····public void HasTypeCode()
2675	····{
2676	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2677	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2678	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2679	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2680	····}
2681	}
2682
2683
2684	[TestFixture]
2685	public class MappingTestCmpBi11OwnpconOthpconTblAuto
2686	{
2687	····PersistenceManager pm;
2688	····NDOMapping mapping;
2689	····Class ownClass;
2690	····Class otherClass;
2691	····Class ownDerivedClass;
2692	····Class otherDerivedClass;
2693	····[SetUp]
2694	····public void Setup()
2695	····{
2696	········this.pm = PmFactory.NewPersistenceManager();
2697	········this.mapping = pm.NDOMapping;
2698	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconTblAutoLeftBase" );
2699	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconTblAutoRightBase" );
2700	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconTblAutoLeftDerived" );
2701	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconTblAutoRightDerived" );
2702	····}
2703	····[Test]
2704	····public void HasMappingTable()
2705	····{
2706	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
2707	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
2708	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
2709	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
2710	····}
2711	····[Test]
2712	····public void HasTypeColumn()
2713	····{
2714	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
2715	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
2716	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
2717	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
2718	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
2719	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
2720	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
2721	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #8") ;
2722	····}
2723	····[Test]
2724	····public void HasTypeCode()
2725	····{
2726	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2727	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2728	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2729	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2730	····}
2731	}
2732
2733
2734	[TestFixture]
2735	public class MappingTestCmpDirnOwnpconOthpconTblAuto
2736	{
2737	····PersistenceManager pm;
2738	····NDOMapping mapping;
2739	····Class ownClass;
2740	····Class otherClass;
2741	····Class ownDerivedClass;
2742	····Class otherDerivedClass;
2743	····[SetUp]
2744	····public void Setup()
2745	····{
2746	········this.pm = PmFactory.NewPersistenceManager();
2747	········this.mapping = pm.NDOMapping;
2748	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconOthpconTblAutoLeftBase" );
2749	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconOthpconTblAutoRightBase" );
2750	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconOthpconTblAutoLeftDerived" );
2751	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconOthpconTblAutoRightDerived" );
2752	····}
2753	····[Test]
2754	····public void HasMappingTable()
2755	····{
2756	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
2757	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
2758	····}
2759	····[Test]
2760	····public void HasTypeColumn()
2761	····{
2762	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
2763	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
2764	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
2765	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
2766	····}
2767	····[Test]
2768	····public void HasTypeCode()
2769	····{
2770	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2771	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2772	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2773	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2774	····}
2775	}
2776
2777
2778	[TestFixture]
2779	public class MappingTestCmpBin1OwnpconOthpconTblAuto
2780	{
2781	····PersistenceManager pm;
2782	····NDOMapping mapping;
2783	····Class ownClass;
2784	····Class otherClass;
2785	····Class ownDerivedClass;
2786	····Class otherDerivedClass;
2787	····[SetUp]
2788	····public void Setup()
2789	····{
2790	········this.pm = PmFactory.NewPersistenceManager();
2791	········this.mapping = pm.NDOMapping;
2792	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconOthpconTblAutoLeftBase" );
2793	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconOthpconTblAutoRightBase" );
2794	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconOthpconTblAutoLeftDerived" );
2795	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconOthpconTblAutoRightDerived" );
2796	····}
2797	····[Test]
2798	····public void HasMappingTable()
2799	····{
2800	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
2801	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
2802	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
2803	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
2804	····}
2805	····[Test]
2806	····public void HasTypeColumn()
2807	····{
2808	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
2809	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
2810	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
2811	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
2812	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
2813	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
2814	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
2815	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #8") ;
2816	····}
2817	····[Test]
2818	····public void HasTypeCode()
2819	····{
2820	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2821	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2822	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2823	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2824	····}
2825	}
2826
2827
2828	[TestFixture]
2829	public class MappingTestCmpBi1nOwnpconOthpconTblAuto
2830	{
2831	····PersistenceManager pm;
2832	····NDOMapping mapping;
2833	····Class ownClass;
2834	····Class otherClass;
2835	····Class ownDerivedClass;
2836	····Class otherDerivedClass;
2837	····[SetUp]
2838	····public void Setup()
2839	····{
2840	········this.pm = PmFactory.NewPersistenceManager();
2841	········this.mapping = pm.NDOMapping;
2842	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconOthpconTblAutoLeftBase" );
2843	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconOthpconTblAutoRightBase" );
2844	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconOthpconTblAutoLeftDerived" );
2845	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconOthpconTblAutoRightDerived" );
2846	····}
2847	····[Test]
2848	····public void HasMappingTable()
2849	····{
2850	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
2851	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
2852	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
2853	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
2854	····}
2855	····[Test]
2856	····public void HasTypeColumn()
2857	····{
2858	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
2859	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
2860	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
2861	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
2862	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
2863	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
2864	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
2865	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #8") ;
2866	····}
2867	····[Test]
2868	····public void HasTypeCode()
2869	····{
2870	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2871	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2872	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2873	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2874	····}
2875	}
2876
2877
2878	[TestFixture]
2879	public class MappingTestCmpBinnOwnpconOthpconTblAuto
2880	{
2881	····PersistenceManager pm;
2882	····NDOMapping mapping;
2883	····Class ownClass;
2884	····Class otherClass;
2885	····Class ownDerivedClass;
2886	····Class otherDerivedClass;
2887	····[SetUp]
2888	····public void Setup()
2889	····{
2890	········this.pm = PmFactory.NewPersistenceManager();
2891	········this.mapping = pm.NDOMapping;
2892	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconOthpconTblAutoLeftBase" );
2893	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconOthpconTblAutoRightBase" );
2894	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconOthpconTblAutoLeftDerived" );
2895	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconOthpconTblAutoRightDerived" );
2896	····}
2897	····[Test]
2898	····public void HasMappingTable()
2899	····{
2900	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
2901	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
2902	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
2903	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
2904	····}
2905	····[Test]
2906	····public void HasTypeColumn()
2907	····{
2908	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
2909	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
2910	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
2911	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
2912	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
2913	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
2914	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
2915	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #8") ;
2916	····}
2917	····[Test]
2918	····public void HasTypeCode()
2919	····{
2920	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2921	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2922	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2923	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2924	····}
2925	}
2926
2927
2928	[TestFixture]
2929	public class MappingTestAgrDir1NoTblGuid
2930	{
2931	····PersistenceManager pm;
2932	····NDOMapping mapping;
2933	····Class ownClass;
2934	····Class otherClass;
2935	····[SetUp]
2936	····public void Setup()
2937	····{
2938	········this.pm = PmFactory.NewPersistenceManager();
2939	········this.mapping = pm.NDOMapping;
2940	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1NoTblGuidLeft" );
2941	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1NoTblGuidRight" );
2942	····}
2943	····[Test]
2944	····public void HasMappingTable()
2945	····{
2946	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
2947	····}
2948	····[Test]
2949	····public void HasTypeColumn()
2950	····{
2951	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
2952	····}
2953	····[Test]
2954	····public void HasTypeCode()
2955	····{
2956	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2957	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2958	····}
2959	}
2960
2961
2962	[TestFixture]
2963	public class MappingTestAgrDir1TblGuid
2964	{
2965	····PersistenceManager pm;
2966	····NDOMapping mapping;
2967	····Class ownClass;
2968	····Class otherClass;
2969	····[SetUp]
2970	····public void Setup()
2971	····{
2972	········this.pm = PmFactory.NewPersistenceManager();
2973	········this.mapping = pm.NDOMapping;
2974	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1TblGuidLeft" );
2975	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1TblGuidRight" );
2976	····}
2977	····[Test]
2978	····public void HasMappingTable()
2979	····{
2980	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
2981	····}
2982	····[Test]
2983	····public void HasTypeColumn()
2984	····{
2985	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
2986	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
2987	····}
2988	····[Test]
2989	····public void HasTypeCode()
2990	····{
2991	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2992	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2993	····}
2994	}
2995
2996
2997	[TestFixture]
2998	public class MappingTestAgrBi11NoTblGuid
2999	{
3000	····PersistenceManager pm;
3001	····NDOMapping mapping;
3002	····Class ownClass;
3003	····Class otherClass;
3004	····[SetUp]
3005	····public void Setup()
3006	····{
3007	········this.pm = PmFactory.NewPersistenceManager();
3008	········this.mapping = pm.NDOMapping;
3009	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11NoTblGuidLeft" );
3010	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11NoTblGuidRight" );
3011	····}
3012	····[Test]
3013	····public void HasMappingTable()
3014	····{
3015	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
3016	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
3017	····}
3018	····[Test]
3019	····public void HasTypeColumn()
3020	····{
3021	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
3022	····}
3023	····[Test]
3024	····public void HasTypeCode()
3025	····{
3026	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3027	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3028	····}
3029	}
3030
3031
3032	[TestFixture]
3033	public class MappingTestAgrBi11TblGuid
3034	{
3035	····PersistenceManager pm;
3036	····NDOMapping mapping;
3037	····Class ownClass;
3038	····Class otherClass;
3039	····[SetUp]
3040	····public void Setup()
3041	····{
3042	········this.pm = PmFactory.NewPersistenceManager();
3043	········this.mapping = pm.NDOMapping;
3044	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11TblGuidLeft" );
3045	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11TblGuidRight" );
3046	····}
3047	····[Test]
3048	····public void HasMappingTable()
3049	····{
3050	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
3051	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
3052	····}
3053	····[Test]
3054	····public void HasTypeColumn()
3055	····{
3056	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
3057	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
3058	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
3059	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
3060	····}
3061	····[Test]
3062	····public void HasTypeCode()
3063	····{
3064	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3065	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3066	····}
3067	}
3068
3069
3070	[TestFixture]
3071	public class MappingTestAgrDirnNoTblGuid
3072	{
3073	····PersistenceManager pm;
3074	····NDOMapping mapping;
3075	····Class ownClass;
3076	····Class otherClass;
3077	····[SetUp]
3078	····public void Setup()
3079	····{
3080	········this.pm = PmFactory.NewPersistenceManager();
3081	········this.mapping = pm.NDOMapping;
3082	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnNoTblGuidLeft" );
3083	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnNoTblGuidRight" );
3084	····}
3085	····[Test]
3086	····public void HasMappingTable()
3087	····{
3088	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
3089	····}
3090	····[Test]
3091	····public void HasTypeColumn()
3092	····{
3093	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
3094	····}
3095	····[Test]
3096	····public void HasTypeCode()
3097	····{
3098	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3099	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3100	····}
3101	}
3102
3103
3104	[TestFixture]
3105	public class MappingTestAgrDirnTblGuid
3106	{
3107	····PersistenceManager pm;
3108	····NDOMapping mapping;
3109	····Class ownClass;
3110	····Class otherClass;
3111	····[SetUp]
3112	····public void Setup()
3113	····{
3114	········this.pm = PmFactory.NewPersistenceManager();
3115	········this.mapping = pm.NDOMapping;
3116	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnTblGuidLeft" );
3117	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnTblGuidRight" );
3118	····}
3119	····[Test]
3120	····public void HasMappingTable()
3121	····{
3122	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
3123	····}
3124	····[Test]
3125	····public void HasTypeColumn()
3126	····{
3127	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
3128	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
3129	····}
3130	····[Test]
3131	····public void HasTypeCode()
3132	····{
3133	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3134	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3135	····}
3136	}
3137
3138
3139	[TestFixture]
3140	public class MappingTestAgrBin1NoTblGuid
3141	{
3142	····PersistenceManager pm;
3143	····NDOMapping mapping;
3144	····Class ownClass;
3145	····Class otherClass;
3146	····[SetUp]
3147	····public void Setup()
3148	····{
3149	········this.pm = PmFactory.NewPersistenceManager();
3150	········this.mapping = pm.NDOMapping;
3151	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1NoTblGuidLeft" );
3152	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1NoTblGuidRight" );
3153	····}
3154	····[Test]
3155	····public void HasMappingTable()
3156	····{
3157	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
3158	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
3159	····}
3160	····[Test]
3161	····public void HasTypeColumn()
3162	····{
3163	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
3164	····}
3165	····[Test]
3166	····public void HasTypeCode()
3167	····{
3168	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3169	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3170	····}
3171	}
3172
3173
3174	[TestFixture]
3175	public class MappingTestAgrBin1TblGuid
3176	{
3177	····PersistenceManager pm;
3178	····NDOMapping mapping;
3179	····Class ownClass;
3180	····Class otherClass;
3181	····[SetUp]
3182	····public void Setup()
3183	····{
3184	········this.pm = PmFactory.NewPersistenceManager();
3185	········this.mapping = pm.NDOMapping;
3186	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1TblGuidLeft" );
3187	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1TblGuidRight" );
3188	····}
3189	····[Test]
3190	····public void HasMappingTable()
3191	····{
3192	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
3193	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
3194	····}
3195	····[Test]
3196	····public void HasTypeColumn()
3197	····{
3198	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
3199	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
3200	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
3201	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
3202	····}
3203	····[Test]
3204	····public void HasTypeCode()
3205	····{
3206	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3207	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3208	····}
3209	}
3210
3211
3212	[TestFixture]
3213	public class MappingTestAgrBi1nNoTblGuid
3214	{
3215	····PersistenceManager pm;
3216	····NDOMapping mapping;
3217	····Class ownClass;
3218	····Class otherClass;
3219	····[SetUp]
3220	····public void Setup()
3221	····{
3222	········this.pm = PmFactory.NewPersistenceManager();
3223	········this.mapping = pm.NDOMapping;
3224	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nNoTblGuidLeft" );
3225	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nNoTblGuidRight" );
3226	····}
3227	····[Test]
3228	····public void HasMappingTable()
3229	····{
3230	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
3231	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
3232	····}
3233	····[Test]
3234	····public void HasTypeColumn()
3235	····{
3236	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
3237	····}
3238	····[Test]
3239	····public void HasTypeCode()
3240	····{
3241	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3242	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3243	····}
3244	}
3245
3246
3247	[TestFixture]
3248	public class MappingTestAgrBi1nTblGuid
3249	{
3250	····PersistenceManager pm;
3251	····NDOMapping mapping;
3252	····Class ownClass;
3253	····Class otherClass;
3254	····[SetUp]
3255	····public void Setup()
3256	····{
3257	········this.pm = PmFactory.NewPersistenceManager();
3258	········this.mapping = pm.NDOMapping;
3259	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nTblGuidLeft" );
3260	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nTblGuidRight" );
3261	····}
3262	····[Test]
3263	····public void HasMappingTable()
3264	····{
3265	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
3266	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
3267	····}
3268	····[Test]
3269	····public void HasTypeColumn()
3270	····{
3271	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
3272	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
3273	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
3274	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
3275	····}
3276	····[Test]
3277	····public void HasTypeCode()
3278	····{
3279	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3280	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3281	····}
3282	}
3283
3284
3285	[TestFixture]
3286	public class MappingTestAgrBinnTblGuid
3287	{
3288	····PersistenceManager pm;
3289	····NDOMapping mapping;
3290	····Class ownClass;
3291	····Class otherClass;
3292	····[SetUp]
3293	····public void Setup()
3294	····{
3295	········this.pm = PmFactory.NewPersistenceManager();
3296	········this.mapping = pm.NDOMapping;
3297	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnTblGuidLeft" );
3298	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnTblGuidRight" );
3299	····}
3300	····[Test]
3301	····public void HasMappingTable()
3302	····{
3303	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
3304	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
3305	····}
3306	····[Test]
3307	····public void HasTypeColumn()
3308	····{
3309	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
3310	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
3311	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
3312	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
3313	····}
3314	····[Test]
3315	····public void HasTypeCode()
3316	····{
3317	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3318	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3319	····}
3320	}
3321
3322
3323	[TestFixture]
3324	public class MappingTestCmpDir1NoTblGuid
3325	{
3326	····PersistenceManager pm;
3327	····NDOMapping mapping;
3328	····Class ownClass;
3329	····Class otherClass;
3330	····[SetUp]
3331	····public void Setup()
3332	····{
3333	········this.pm = PmFactory.NewPersistenceManager();
3334	········this.mapping = pm.NDOMapping;
3335	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1NoTblGuidLeft" );
3336	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1NoTblGuidRight" );
3337	····}
3338	····[Test]
3339	····public void HasMappingTable()
3340	····{
3341	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
3342	····}
3343	····[Test]
3344	····public void HasTypeColumn()
3345	····{
3346	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
3347	····}
3348	····[Test]
3349	····public void HasTypeCode()
3350	····{
3351	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3352	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3353	····}
3354	}
3355
3356
3357	[TestFixture]
3358	public class MappingTestCmpDir1TblGuid
3359	{
3360	····PersistenceManager pm;
3361	····NDOMapping mapping;
3362	····Class ownClass;
3363	····Class otherClass;
3364	····[SetUp]
3365	····public void Setup()
3366	····{
3367	········this.pm = PmFactory.NewPersistenceManager();
3368	········this.mapping = pm.NDOMapping;
3369	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1TblGuidLeft" );
3370	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1TblGuidRight" );
3371	····}
3372	····[Test]
3373	····public void HasMappingTable()
3374	····{
3375	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
3376	····}
3377	····[Test]
3378	····public void HasTypeColumn()
3379	····{
3380	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
3381	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
3382	····}
3383	····[Test]
3384	····public void HasTypeCode()
3385	····{
3386	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3387	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3388	····}
3389	}
3390
3391
3392	[TestFixture]
3393	public class MappingTestCmpBi11NoTblGuid
3394	{
3395	····PersistenceManager pm;
3396	····NDOMapping mapping;
3397	····Class ownClass;
3398	····Class otherClass;
3399	····[SetUp]
3400	····public void Setup()
3401	····{
3402	········this.pm = PmFactory.NewPersistenceManager();
3403	········this.mapping = pm.NDOMapping;
3404	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11NoTblGuidLeft" );
3405	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11NoTblGuidRight" );
3406	····}
3407	····[Test]
3408	····public void HasMappingTable()
3409	····{
3410	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
3411	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
3412	····}
3413	····[Test]
3414	····public void HasTypeColumn()
3415	····{
3416	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
3417	····}
3418	····[Test]
3419	····public void HasTypeCode()
3420	····{
3421	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3422	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3423	····}
3424	}
3425
3426
3427	[TestFixture]
3428	public class MappingTestCmpBi11TblGuid
3429	{
3430	····PersistenceManager pm;
3431	····NDOMapping mapping;
3432	····Class ownClass;
3433	····Class otherClass;
3434	····[SetUp]
3435	····public void Setup()
3436	····{
3437	········this.pm = PmFactory.NewPersistenceManager();
3438	········this.mapping = pm.NDOMapping;
3439	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11TblGuidLeft" );
3440	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11TblGuidRight" );
3441	····}
3442	····[Test]
3443	····public void HasMappingTable()
3444	····{
3445	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
3446	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
3447	····}
3448	····[Test]
3449	····public void HasTypeColumn()
3450	····{
3451	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
3452	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
3453	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
3454	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
3455	····}
3456	····[Test]
3457	····public void HasTypeCode()
3458	····{
3459	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3460	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3461	····}
3462	}
3463
3464
3465	[TestFixture]
3466	public class MappingTestCmpDirnNoTblGuid
3467	{
3468	····PersistenceManager pm;
3469	····NDOMapping mapping;
3470	····Class ownClass;
3471	····Class otherClass;
3472	····[SetUp]
3473	····public void Setup()
3474	····{
3475	········this.pm = PmFactory.NewPersistenceManager();
3476	········this.mapping = pm.NDOMapping;
3477	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnNoTblGuidLeft" );
3478	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnNoTblGuidRight" );
3479	····}
3480	····[Test]
3481	····public void HasMappingTable()
3482	····{
3483	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
3484	····}
3485	····[Test]
3486	····public void HasTypeColumn()
3487	····{
3488	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
3489	····}
3490	····[Test]
3491	····public void HasTypeCode()
3492	····{
3493	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3494	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3495	····}
3496	}
3497
3498
3499	[TestFixture]
3500	public class MappingTestCmpDirnTblGuid
3501	{
3502	····PersistenceManager pm;
3503	····NDOMapping mapping;
3504	····Class ownClass;
3505	····Class otherClass;
3506	····[SetUp]
3507	····public void Setup()
3508	····{
3509	········this.pm = PmFactory.NewPersistenceManager();
3510	········this.mapping = pm.NDOMapping;
3511	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnTblGuidLeft" );
3512	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnTblGuidRight" );
3513	····}
3514	····[Test]
3515	····public void HasMappingTable()
3516	····{
3517	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
3518	····}
3519	····[Test]
3520	····public void HasTypeColumn()
3521	····{
3522	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
3523	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
3524	····}
3525	····[Test]
3526	····public void HasTypeCode()
3527	····{
3528	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3529	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3530	····}
3531	}
3532
3533
3534	[TestFixture]
3535	public class MappingTestCmpBin1NoTblGuid
3536	{
3537	····PersistenceManager pm;
3538	····NDOMapping mapping;
3539	····Class ownClass;
3540	····Class otherClass;
3541	····[SetUp]
3542	····public void Setup()
3543	····{
3544	········this.pm = PmFactory.NewPersistenceManager();
3545	········this.mapping = pm.NDOMapping;
3546	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1NoTblGuidLeft" );
3547	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1NoTblGuidRight" );
3548	····}
3549	····[Test]
3550	····public void HasMappingTable()
3551	····{
3552	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
3553	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
3554	····}
3555	····[Test]
3556	····public void HasTypeColumn()
3557	····{
3558	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
3559	····}
3560	····[Test]
3561	····public void HasTypeCode()
3562	····{
3563	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3564	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3565	····}
3566	}
3567
3568
3569	[TestFixture]
3570	public class MappingTestCmpBin1TblGuid
3571	{
3572	····PersistenceManager pm;
3573	····NDOMapping mapping;
3574	····Class ownClass;
3575	····Class otherClass;
3576	····[SetUp]
3577	····public void Setup()
3578	····{
3579	········this.pm = PmFactory.NewPersistenceManager();
3580	········this.mapping = pm.NDOMapping;
3581	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1TblGuidLeft" );
3582	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1TblGuidRight" );
3583	····}
3584	····[Test]
3585	····public void HasMappingTable()
3586	····{
3587	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
3588	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
3589	····}
3590	····[Test]
3591	····public void HasTypeColumn()
3592	····{
3593	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
3594	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
3595	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
3596	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
3597	····}
3598	····[Test]
3599	····public void HasTypeCode()
3600	····{
3601	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3602	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3603	····}
3604	}
3605
3606
3607	[TestFixture]
3608	public class MappingTestCmpBi1nNoTblGuid
3609	{
3610	····PersistenceManager pm;
3611	····NDOMapping mapping;
3612	····Class ownClass;
3613	····Class otherClass;
3614	····[SetUp]
3615	····public void Setup()
3616	····{
3617	········this.pm = PmFactory.NewPersistenceManager();
3618	········this.mapping = pm.NDOMapping;
3619	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nNoTblGuidLeft" );
3620	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nNoTblGuidRight" );
3621	····}
3622	····[Test]
3623	····public void HasMappingTable()
3624	····{
3625	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
3626	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
3627	····}
3628	····[Test]
3629	····public void HasTypeColumn()
3630	····{
3631	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
3632	····}
3633	····[Test]
3634	····public void HasTypeCode()
3635	····{
3636	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3637	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3638	····}
3639	}
3640
3641
3642	[TestFixture]
3643	public class MappingTestCmpBi1nTblGuid
3644	{
3645	····PersistenceManager pm;
3646	····NDOMapping mapping;
3647	····Class ownClass;
3648	····Class otherClass;
3649	····[SetUp]
3650	····public void Setup()
3651	····{
3652	········this.pm = PmFactory.NewPersistenceManager();
3653	········this.mapping = pm.NDOMapping;
3654	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nTblGuidLeft" );
3655	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nTblGuidRight" );
3656	····}
3657	····[Test]
3658	····public void HasMappingTable()
3659	····{
3660	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
3661	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
3662	····}
3663	····[Test]
3664	····public void HasTypeColumn()
3665	····{
3666	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
3667	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
3668	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
3669	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
3670	····}
3671	····[Test]
3672	····public void HasTypeCode()
3673	····{
3674	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3675	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3676	····}
3677	}
3678
3679
3680	[TestFixture]
3681	public class MappingTestCmpBinnTblGuid
3682	{
3683	····PersistenceManager pm;
3684	····NDOMapping mapping;
3685	····Class ownClass;
3686	····Class otherClass;
3687	····[SetUp]
3688	····public void Setup()
3689	····{
3690	········this.pm = PmFactory.NewPersistenceManager();
3691	········this.mapping = pm.NDOMapping;
3692	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnTblGuidLeft" );
3693	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnTblGuidRight" );
3694	····}
3695	····[Test]
3696	····public void HasMappingTable()
3697	····{
3698	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
3699	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
3700	····}
3701	····[Test]
3702	····public void HasTypeColumn()
3703	····{
3704	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
3705	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
3706	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
3707	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
3708	····}
3709	····[Test]
3710	····public void HasTypeCode()
3711	····{
3712	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3713	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3714	····}
3715	}
3716
3717
3718	[TestFixture]
3719	public class MappingTestAgrDir1OwnpconNoTblGuid
3720	{
3721	····PersistenceManager pm;
3722	····NDOMapping mapping;
3723	····Class ownClass;
3724	····Class otherClass;
3725	····Class ownDerivedClass;
3726	····[SetUp]
3727	····public void Setup()
3728	····{
3729	········this.pm = PmFactory.NewPersistenceManager();
3730	········this.mapping = pm.NDOMapping;
3731	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconNoTblGuidLeftBase" );
3732	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconNoTblGuidRight" );
3733	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconNoTblGuidLeftDerived" );
3734	····}
3735	····[Test]
3736	····public void HasMappingTable()
3737	····{
3738	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
3739	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
3740	····}
3741	····[Test]
3742	····public void HasTypeColumn()
3743	····{
3744	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
3745	····}
3746	····[Test]
3747	····public void HasTypeCode()
3748	····{
3749	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3750	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3751	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
3752	····}
3753	}
3754
3755
3756	[TestFixture]
3757	public class MappingTestAgrDir1OwnpconTblGuid
3758	{
3759	····PersistenceManager pm;
3760	····NDOMapping mapping;
3761	····Class ownClass;
3762	····Class otherClass;
3763	····Class ownDerivedClass;
3764	····[SetUp]
3765	····public void Setup()
3766	····{
3767	········this.pm = PmFactory.NewPersistenceManager();
3768	········this.mapping = pm.NDOMapping;
3769	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconTblGuidLeftBase" );
3770	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconTblGuidRight" );
3771	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconTblGuidLeftDerived" );
3772	····}
3773	····[Test]
3774	····public void HasMappingTable()
3775	····{
3776	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
3777	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
3778	····}
3779	····[Test]
3780	····public void HasTypeColumn()
3781	····{
3782	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
3783	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
3784	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
3785	····}
3786	····[Test]
3787	····public void HasTypeCode()
3788	····{
3789	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3790	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3791	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
3792	····}
3793	}
3794
3795
3796	[TestFixture]
3797	public class MappingTestAgrBi11OwnpconNoTblGuid
3798	{
3799	····PersistenceManager pm;
3800	····NDOMapping mapping;
3801	····Class ownClass;
3802	····Class otherClass;
3803	····Class ownDerivedClass;
3804	····[SetUp]
3805	····public void Setup()
3806	····{
3807	········this.pm = PmFactory.NewPersistenceManager();
3808	········this.mapping = pm.NDOMapping;
3809	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconNoTblGuidLeftBase" );
3810	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconNoTblGuidRight" );
3811	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconNoTblGuidLeftDerived" );
3812	····}
3813	····[Test]
3814	····public void HasMappingTable()
3815	····{
3816	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
3817	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
3818	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
3819	····}
3820	····[Test]
3821	····public void HasTypeColumn()
3822	····{
3823	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
3824	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #10") ;
3825	····}
3826	····[Test]
3827	····public void HasTypeCode()
3828	····{
3829	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3830	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3831	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
3832	····}
3833	}
3834
3835
3836	[TestFixture]
3837	public class MappingTestAgrBi11OwnpconTblGuid
3838	{
3839	····PersistenceManager pm;
3840	····NDOMapping mapping;
3841	····Class ownClass;
3842	····Class otherClass;
3843	····Class ownDerivedClass;
3844	····[SetUp]
3845	····public void Setup()
3846	····{
3847	········this.pm = PmFactory.NewPersistenceManager();
3848	········this.mapping = pm.NDOMapping;
3849	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconTblGuidLeftBase" );
3850	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconTblGuidRight" );
3851	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconTblGuidLeftDerived" );
3852	····}
3853	····[Test]
3854	····public void HasMappingTable()
3855	····{
3856	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
3857	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
3858	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
3859	····}
3860	····[Test]
3861	····public void HasTypeColumn()
3862	····{
3863	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
3864	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
3865	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
3866	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
3867	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
3868	····}
3869	····[Test]
3870	····public void HasTypeCode()
3871	····{
3872	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3873	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3874	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
3875	····}
3876	}
3877
3878
3879	[TestFixture]
3880	public class MappingTestAgrDirnOwnpconNoTblGuid
3881	{
3882	····PersistenceManager pm;
3883	····NDOMapping mapping;
3884	····Class ownClass;
3885	····Class otherClass;
3886	····Class ownDerivedClass;
3887	····[SetUp]
3888	····public void Setup()
3889	····{
3890	········this.pm = PmFactory.NewPersistenceManager();
3891	········this.mapping = pm.NDOMapping;
3892	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconNoTblGuidLeftBase" );
3893	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconNoTblGuidRight" );
3894	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconNoTblGuidLeftDerived" );
3895	····}
3896	····[Test]
3897	····public void HasMappingTable()
3898	····{
3899	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
3900	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
3901	····}
3902	····[Test]
3903	····public void HasTypeColumn()
3904	····{
3905	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
3906	····}
3907	····[Test]
3908	····public void HasTypeCode()
3909	····{
3910	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3911	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3912	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
3913	····}
3914	}
3915
3916
3917	[TestFixture]
3918	public class MappingTestAgrDirnOwnpconTblGuid
3919	{
3920	····PersistenceManager pm;
3921	····NDOMapping mapping;
3922	····Class ownClass;
3923	····Class otherClass;
3924	····Class ownDerivedClass;
3925	····[SetUp]
3926	····public void Setup()
3927	····{
3928	········this.pm = PmFactory.NewPersistenceManager();
3929	········this.mapping = pm.NDOMapping;
3930	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconTblGuidLeftBase" );
3931	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconTblGuidRight" );
3932	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconTblGuidLeftDerived" );
3933	····}
3934	····[Test]
3935	····public void HasMappingTable()
3936	····{
3937	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
3938	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
3939	····}
3940	····[Test]
3941	····public void HasTypeColumn()
3942	····{
3943	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
3944	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
3945	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
3946	····}
3947	····[Test]
3948	····public void HasTypeCode()
3949	····{
3950	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3951	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3952	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
3953	····}
3954	}
3955
3956
3957	[TestFixture]
3958	public class MappingTestAgrBin1OwnpconNoTblGuid
3959	{
3960	····PersistenceManager pm;
3961	····NDOMapping mapping;
3962	····Class ownClass;
3963	····Class otherClass;
3964	····Class ownDerivedClass;
3965	····[SetUp]
3966	····public void Setup()
3967	····{
3968	········this.pm = PmFactory.NewPersistenceManager();
3969	········this.mapping = pm.NDOMapping;
3970	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconNoTblGuidLeftBase" );
3971	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconNoTblGuidRight" );
3972	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconNoTblGuidLeftDerived" );
3973	····}
3974	····[Test]
3975	····public void HasMappingTable()
3976	····{
3977	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
3978	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
3979	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
3980	····}
3981	····[Test]
3982	····public void HasTypeColumn()
3983	····{
3984	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
3985	····}
3986	····[Test]
3987	····public void HasTypeCode()
3988	····{
3989	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3990	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3991	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
3992	····}
3993	}
3994
3995
3996	[TestFixture]
3997	public class MappingTestAgrBin1OwnpconTblGuid
3998	{
3999	····PersistenceManager pm;
4000	····NDOMapping mapping;
4001	····Class ownClass;
4002	····Class otherClass;
4003	····Class ownDerivedClass;
4004	····[SetUp]
4005	····public void Setup()
4006	····{
4007	········this.pm = PmFactory.NewPersistenceManager();
4008	········this.mapping = pm.NDOMapping;
4009	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconTblGuidLeftBase" );
4010	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconTblGuidRight" );
4011	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconTblGuidLeftDerived" );
4012	····}
4013	····[Test]
4014	····public void HasMappingTable()
4015	····{
4016	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
4017	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
4018	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
4019	····}
4020	····[Test]
4021	····public void HasTypeColumn()
4022	····{
4023	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
4024	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
4025	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
4026	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
4027	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
4028	····}
4029	····[Test]
4030	····public void HasTypeCode()
4031	····{
4032	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4033	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4034	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4035	····}
4036	}
4037
4038
4039	[TestFixture]
4040	public class MappingTestAgrBi1nOwnpconTblGuid
4041	{
4042	····PersistenceManager pm;
4043	····NDOMapping mapping;
4044	····Class ownClass;
4045	····Class otherClass;
4046	····Class ownDerivedClass;
4047	····[SetUp]
4048	····public void Setup()
4049	····{
4050	········this.pm = PmFactory.NewPersistenceManager();
4051	········this.mapping = pm.NDOMapping;
4052	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconTblGuidLeftBase" );
4053	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconTblGuidRight" );
4054	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconTblGuidLeftDerived" );
4055	····}
4056	····[Test]
4057	····public void HasMappingTable()
4058	····{
4059	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
4060	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
4061	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
4062	····}
4063	····[Test]
4064	····public void HasTypeColumn()
4065	····{
4066	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
4067	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
4068	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
4069	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
4070	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
4071	····}
4072	····[Test]
4073	····public void HasTypeCode()
4074	····{
4075	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4076	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4077	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4078	····}
4079	}
4080
4081
4082	[TestFixture]
4083	public class MappingTestAgrBinnOwnpconTblGuid
4084	{
4085	····PersistenceManager pm;
4086	····NDOMapping mapping;
4087	····Class ownClass;
4088	····Class otherClass;
4089	····Class ownDerivedClass;
4090	····[SetUp]
4091	····public void Setup()
4092	····{
4093	········this.pm = PmFactory.NewPersistenceManager();
4094	········this.mapping = pm.NDOMapping;
4095	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconTblGuidLeftBase" );
4096	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconTblGuidRight" );
4097	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconTblGuidLeftDerived" );
4098	····}
4099	····[Test]
4100	····public void HasMappingTable()
4101	····{
4102	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
4103	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
4104	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
4105	····}
4106	····[Test]
4107	····public void HasTypeColumn()
4108	····{
4109	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
4110	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
4111	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
4112	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
4113	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
4114	····}
4115	····[Test]
4116	····public void HasTypeCode()
4117	····{
4118	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4119	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4120	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4121	····}
4122	}
4123
4124
4125	[TestFixture]
4126	public class MappingTestCmpDir1OwnpconNoTblGuid
4127	{
4128	····PersistenceManager pm;
4129	····NDOMapping mapping;
4130	····Class ownClass;
4131	····Class otherClass;
4132	····Class ownDerivedClass;
4133	····[SetUp]
4134	····public void Setup()
4135	····{
4136	········this.pm = PmFactory.NewPersistenceManager();
4137	········this.mapping = pm.NDOMapping;
4138	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconNoTblGuidLeftBase" );
4139	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconNoTblGuidRight" );
4140	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconNoTblGuidLeftDerived" );
4141	····}
4142	····[Test]
4143	····public void HasMappingTable()
4144	····{
4145	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
4146	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
4147	····}
4148	····[Test]
4149	····public void HasTypeColumn()
4150	····{
4151	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
4152	····}
4153	····[Test]
4154	····public void HasTypeCode()
4155	····{
4156	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4157	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4158	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4159	····}
4160	}
4161
4162
4163	[TestFixture]
4164	public class MappingTestCmpDir1OwnpconTblGuid
4165	{
4166	····PersistenceManager pm;
4167	····NDOMapping mapping;
4168	····Class ownClass;
4169	····Class otherClass;
4170	····Class ownDerivedClass;
4171	····[SetUp]
4172	····public void Setup()
4173	····{
4174	········this.pm = PmFactory.NewPersistenceManager();
4175	········this.mapping = pm.NDOMapping;
4176	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconTblGuidLeftBase" );
4177	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconTblGuidRight" );
4178	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconTblGuidLeftDerived" );
4179	····}
4180	····[Test]
4181	····public void HasMappingTable()
4182	····{
4183	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
4184	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
4185	····}
4186	····[Test]
4187	····public void HasTypeColumn()
4188	····{
4189	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
4190	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
4191	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
4192	····}
4193	····[Test]
4194	····public void HasTypeCode()
4195	····{
4196	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4197	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4198	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4199	····}
4200	}
4201
4202
4203	[TestFixture]
4204	public class MappingTestCmpBi11OwnpconNoTblGuid
4205	{
4206	····PersistenceManager pm;
4207	····NDOMapping mapping;
4208	····Class ownClass;
4209	····Class otherClass;
4210	····Class ownDerivedClass;
4211	····[SetUp]
4212	····public void Setup()
4213	····{
4214	········this.pm = PmFactory.NewPersistenceManager();
4215	········this.mapping = pm.NDOMapping;
4216	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconNoTblGuidLeftBase" );
4217	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconNoTblGuidRight" );
4218	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconNoTblGuidLeftDerived" );
4219	····}
4220	····[Test]
4221	····public void HasMappingTable()
4222	····{
4223	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
4224	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
4225	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
4226	····}
4227	····[Test]
4228	····public void HasTypeColumn()
4229	····{
4230	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
4231	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #10") ;
4232	····}
4233	····[Test]
4234	····public void HasTypeCode()
4235	····{
4236	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4237	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4238	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4239	····}
4240	}
4241
4242
4243	[TestFixture]
4244	public class MappingTestCmpBi11OwnpconTblGuid
4245	{
4246	····PersistenceManager pm;
4247	····NDOMapping mapping;
4248	····Class ownClass;
4249	····Class otherClass;
4250	····Class ownDerivedClass;
4251	····[SetUp]
4252	····public void Setup()
4253	····{
4254	········this.pm = PmFactory.NewPersistenceManager();
4255	········this.mapping = pm.NDOMapping;
4256	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconTblGuidLeftBase" );
4257	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconTblGuidRight" );
4258	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconTblGuidLeftDerived" );
4259	····}
4260	····[Test]
4261	····public void HasMappingTable()
4262	····{
4263	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
4264	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
4265	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
4266	····}
4267	····[Test]
4268	····public void HasTypeColumn()
4269	····{
4270	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
4271	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
4272	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
4273	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
4274	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
4275	····}
4276	····[Test]
4277	····public void HasTypeCode()
4278	····{
4279	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4280	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4281	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4282	····}
4283	}
4284
4285
4286	[TestFixture]
4287	public class MappingTestCmpDirnOwnpconNoTblGuid
4288	{
4289	····PersistenceManager pm;
4290	····NDOMapping mapping;
4291	····Class ownClass;
4292	····Class otherClass;
4293	····Class ownDerivedClass;
4294	····[SetUp]
4295	····public void Setup()
4296	····{
4297	········this.pm = PmFactory.NewPersistenceManager();
4298	········this.mapping = pm.NDOMapping;
4299	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconNoTblGuidLeftBase" );
4300	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconNoTblGuidRight" );
4301	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconNoTblGuidLeftDerived" );
4302	····}
4303	····[Test]
4304	····public void HasMappingTable()
4305	····{
4306	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
4307	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
4308	····}
4309	····[Test]
4310	····public void HasTypeColumn()
4311	····{
4312	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
4313	····}
4314	····[Test]
4315	····public void HasTypeCode()
4316	····{
4317	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4318	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4319	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4320	····}
4321	}
4322
4323
4324	[TestFixture]
4325	public class MappingTestCmpDirnOwnpconTblGuid
4326	{
4327	····PersistenceManager pm;
4328	····NDOMapping mapping;
4329	····Class ownClass;
4330	····Class otherClass;
4331	····Class ownDerivedClass;
4332	····[SetUp]
4333	····public void Setup()
4334	····{
4335	········this.pm = PmFactory.NewPersistenceManager();
4336	········this.mapping = pm.NDOMapping;
4337	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconTblGuidLeftBase" );
4338	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconTblGuidRight" );
4339	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconTblGuidLeftDerived" );
4340	····}
4341	····[Test]
4342	····public void HasMappingTable()
4343	····{
4344	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
4345	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
4346	····}
4347	····[Test]
4348	····public void HasTypeColumn()
4349	····{
4350	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
4351	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
4352	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
4353	····}
4354	····[Test]
4355	····public void HasTypeCode()
4356	····{
4357	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4358	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4359	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4360	····}
4361	}
4362
4363
4364	[TestFixture]
4365	public class MappingTestCmpBin1OwnpconNoTblGuid
4366	{
4367	····PersistenceManager pm;
4368	····NDOMapping mapping;
4369	····Class ownClass;
4370	····Class otherClass;
4371	····Class ownDerivedClass;
4372	····[SetUp]
4373	····public void Setup()
4374	····{
4375	········this.pm = PmFactory.NewPersistenceManager();
4376	········this.mapping = pm.NDOMapping;
4377	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconNoTblGuidLeftBase" );
4378	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconNoTblGuidRight" );
4379	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconNoTblGuidLeftDerived" );
4380	····}
4381	····[Test]
4382	····public void HasMappingTable()
4383	····{
4384	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
4385	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
4386	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
4387	····}
4388	····[Test]
4389	····public void HasTypeColumn()
4390	····{
4391	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
4392	····}
4393	····[Test]
4394	····public void HasTypeCode()
4395	····{
4396	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4397	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4398	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4399	····}
4400	}
4401
4402
4403	[TestFixture]
4404	public class MappingTestCmpBin1OwnpconTblGuid
4405	{
4406	····PersistenceManager pm;
4407	····NDOMapping mapping;
4408	····Class ownClass;
4409	····Class otherClass;
4410	····Class ownDerivedClass;
4411	····[SetUp]
4412	····public void Setup()
4413	····{
4414	········this.pm = PmFactory.NewPersistenceManager();
4415	········this.mapping = pm.NDOMapping;
4416	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconTblGuidLeftBase" );
4417	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconTblGuidRight" );
4418	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconTblGuidLeftDerived" );
4419	····}
4420	····[Test]
4421	····public void HasMappingTable()
4422	····{
4423	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
4424	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
4425	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
4426	····}
4427	····[Test]
4428	····public void HasTypeColumn()
4429	····{
4430	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
4431	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
4432	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
4433	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
4434	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
4435	····}
4436	····[Test]
4437	····public void HasTypeCode()
4438	····{
4439	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4440	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4441	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4442	····}
4443	}
4444
4445
4446	[TestFixture]
4447	public class MappingTestCmpBi1nOwnpconTblGuid
4448	{
4449	····PersistenceManager pm;
4450	····NDOMapping mapping;
4451	····Class ownClass;
4452	····Class otherClass;
4453	····Class ownDerivedClass;
4454	····[SetUp]
4455	····public void Setup()
4456	····{
4457	········this.pm = PmFactory.NewPersistenceManager();
4458	········this.mapping = pm.NDOMapping;
4459	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconTblGuidLeftBase" );
4460	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconTblGuidRight" );
4461	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconTblGuidLeftDerived" );
4462	····}
4463	····[Test]
4464	····public void HasMappingTable()
4465	····{
4466	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
4467	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
4468	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
4469	····}
4470	····[Test]
4471	····public void HasTypeColumn()
4472	····{
4473	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
4474	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
4475	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
4476	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
4477	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
4478	····}
4479	····[Test]
4480	····public void HasTypeCode()
4481	····{
4482	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4483	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4484	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4485	····}
4486	}
4487
4488
4489	[TestFixture]
4490	public class MappingTestCmpBinnOwnpconTblGuid
4491	{
4492	····PersistenceManager pm;
4493	····NDOMapping mapping;
4494	····Class ownClass;
4495	····Class otherClass;
4496	····Class ownDerivedClass;
4497	····[SetUp]
4498	····public void Setup()
4499	····{
4500	········this.pm = PmFactory.NewPersistenceManager();
4501	········this.mapping = pm.NDOMapping;
4502	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconTblGuidLeftBase" );
4503	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconTblGuidRight" );
4504	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconTblGuidLeftDerived" );
4505	····}
4506	····[Test]
4507	····public void HasMappingTable()
4508	····{
4509	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
4510	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
4511	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
4512	····}
4513	····[Test]
4514	····public void HasTypeColumn()
4515	····{
4516	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
4517	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
4518	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
4519	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
4520	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
4521	····}
4522	····[Test]
4523	····public void HasTypeCode()
4524	····{
4525	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4526	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4527	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4528	····}
4529	}
4530
4531
4532	[TestFixture]
4533	public class MappingTestAgrDir1OthpconNoTblGuid
4534	{
4535	····PersistenceManager pm;
4536	····NDOMapping mapping;
4537	····Class ownClass;
4538	····Class otherClass;
4539	····Class otherDerivedClass;
4540	····[SetUp]
4541	····public void Setup()
4542	····{
4543	········this.pm = PmFactory.NewPersistenceManager();
4544	········this.mapping = pm.NDOMapping;
4545	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconNoTblGuidLeft" );
4546	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconNoTblGuidRightBase" );
4547	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconNoTblGuidRightDerived" );
4548	····}
4549	····[Test]
4550	····public void HasMappingTable()
4551	····{
4552	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
4553	····}
4554	····[Test]
4555	····public void HasTypeColumn()
4556	····{
4557	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #9") ;
4558	····}
4559	····[Test]
4560	····public void HasTypeCode()
4561	····{
4562	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4563	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4564	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4565	····}
4566	}
4567
4568
4569	[TestFixture]
4570	public class MappingTestAgrDir1OthpconTblGuid
4571	{
4572	····PersistenceManager pm;
4573	····NDOMapping mapping;
4574	····Class ownClass;
4575	····Class otherClass;
4576	····Class otherDerivedClass;
4577	····[SetUp]
4578	····public void Setup()
4579	····{
4580	········this.pm = PmFactory.NewPersistenceManager();
4581	········this.mapping = pm.NDOMapping;
4582	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconTblGuidLeft" );
4583	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconTblGuidRightBase" );
4584	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconTblGuidRightDerived" );
4585	····}
4586	····[Test]
4587	····public void HasMappingTable()
4588	····{
4589	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
4590	····}
4591	····[Test]
4592	····public void HasTypeColumn()
4593	····{
4594	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
4595	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
4596	····}
4597	····[Test]
4598	····public void HasTypeCode()
4599	····{
4600	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4601	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4602	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4603	····}
4604	}
4605
4606
4607	[TestFixture]
4608	public class MappingTestAgrBi11OthpconNoTblGuid
4609	{
4610	····PersistenceManager pm;
4611	····NDOMapping mapping;
4612	····Class ownClass;
4613	····Class otherClass;
4614	····Class otherDerivedClass;
4615	····[SetUp]
4616	····public void Setup()
4617	····{
4618	········this.pm = PmFactory.NewPersistenceManager();
4619	········this.mapping = pm.NDOMapping;
4620	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconNoTblGuidLeft" );
4621	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconNoTblGuidRightBase" );
4622	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconNoTblGuidRightDerived" );
4623	····}
4624	····[Test]
4625	····public void HasMappingTable()
4626	····{
4627	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
4628	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
4629	Assert. Null( otherDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #8") ;
4630	····}
4631	····[Test]
4632	····public void HasTypeColumn()
4633	····{
4634	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #9") ;
4635	····}
4636	····[Test]
4637	····public void HasTypeCode()
4638	····{
4639	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4640	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4641	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4642	····}
4643	}
4644
4645
4646	[TestFixture]
4647	public class MappingTestAgrBi11OthpconTblGuid
4648	{
4649	····PersistenceManager pm;
4650	····NDOMapping mapping;
4651	····Class ownClass;
4652	····Class otherClass;
4653	····Class otherDerivedClass;
4654	····[SetUp]
4655	····public void Setup()
4656	····{
4657	········this.pm = PmFactory.NewPersistenceManager();
4658	········this.mapping = pm.NDOMapping;
4659	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconTblGuidLeft" );
4660	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconTblGuidRightBase" );
4661	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconTblGuidRightDerived" );
4662	····}
4663	····[Test]
4664	····public void HasMappingTable()
4665	····{
4666	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
4667	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
4668	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
4669	····}
4670	····[Test]
4671	····public void HasTypeColumn()
4672	····{
4673	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
4674	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
4675	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
4676	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
4677	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
4678	····}
4679	····[Test]
4680	····public void HasTypeCode()
4681	····{
4682	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4683	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4684	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4685	····}
4686	}
4687
4688
4689	[TestFixture]
4690	public class MappingTestAgrDirnOthpconTblGuid
4691	{
4692	····PersistenceManager pm;
4693	····NDOMapping mapping;
4694	····Class ownClass;
4695	····Class otherClass;
4696	····Class otherDerivedClass;
4697	····[SetUp]
4698	····public void Setup()
4699	····{
4700	········this.pm = PmFactory.NewPersistenceManager();
4701	········this.mapping = pm.NDOMapping;
4702	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpconTblGuidLeft" );
4703	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpconTblGuidRightBase" );
4704	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpconTblGuidRightDerived" );
4705	····}
4706	····[Test]
4707	····public void HasMappingTable()
4708	····{
4709	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
4710	····}
4711	····[Test]
4712	····public void HasTypeColumn()
4713	····{
4714	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
4715	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
4716	····}
4717	····[Test]
4718	····public void HasTypeCode()
4719	····{
4720	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4721	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4722	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4723	····}
4724	}
4725
4726
4727	[TestFixture]
4728	public class MappingTestAgrBin1OthpconTblGuid
4729	{
4730	····PersistenceManager pm;
4731	····NDOMapping mapping;
4732	····Class ownClass;
4733	····Class otherClass;
4734	····Class otherDerivedClass;
4735	····[SetUp]
4736	····public void Setup()
4737	····{
4738	········this.pm = PmFactory.NewPersistenceManager();
4739	········this.mapping = pm.NDOMapping;
4740	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpconTblGuidLeft" );
4741	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpconTblGuidRightBase" );
4742	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpconTblGuidRightDerived" );
4743	····}
4744	····[Test]
4745	····public void HasMappingTable()
4746	····{
4747	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
4748	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
4749	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
4750	····}
4751	····[Test]
4752	····public void HasTypeColumn()
4753	····{
4754	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
4755	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
4756	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
4757	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
4758	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
4759	····}
4760	····[Test]
4761	····public void HasTypeCode()
4762	····{
4763	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4764	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4765	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4766	····}
4767	}
4768
4769
4770	[TestFixture]
4771	public class MappingTestAgrBi1nOthpconNoTblGuid
4772	{
4773	····PersistenceManager pm;
4774	····NDOMapping mapping;
4775	····Class ownClass;
4776	····Class otherClass;
4777	····Class otherDerivedClass;
4778	····[SetUp]
4779	····public void Setup()
4780	····{
4781	········this.pm = PmFactory.NewPersistenceManager();
4782	········this.mapping = pm.NDOMapping;
4783	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconNoTblGuidLeft" );
4784	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconNoTblGuidRightBase" );
4785	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconNoTblGuidRightDerived" );
4786	····}
4787	····[Test]
4788	····public void HasMappingTable()
4789	····{
4790	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
4791	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
4792	Assert. Null( otherDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #8") ;
4793	····}
4794	····[Test]
4795	····public void HasTypeColumn()
4796	····{
4797	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #9") ;
4798	····}
4799	····[Test]
4800	····public void HasTypeCode()
4801	····{
4802	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4803	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4804	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4805	····}
4806	}
4807
4808
4809	[TestFixture]
4810	public class MappingTestAgrBi1nOthpconTblGuid
4811	{
4812	····PersistenceManager pm;
4813	····NDOMapping mapping;
4814	····Class ownClass;
4815	····Class otherClass;
4816	····Class otherDerivedClass;
4817	····[SetUp]
4818	····public void Setup()
4819	····{
4820	········this.pm = PmFactory.NewPersistenceManager();
4821	········this.mapping = pm.NDOMapping;
4822	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconTblGuidLeft" );
4823	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconTblGuidRightBase" );
4824	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconTblGuidRightDerived" );
4825	····}
4826	····[Test]
4827	····public void HasMappingTable()
4828	····{
4829	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
4830	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
4831	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
4832	····}
4833	····[Test]
4834	····public void HasTypeColumn()
4835	····{
4836	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
4837	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
4838	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
4839	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
4840	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
4841	····}
4842	····[Test]
4843	····public void HasTypeCode()
4844	····{
4845	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4846	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4847	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4848	····}
4849	}
4850
4851
4852	[TestFixture]
4853	public class MappingTestAgrBinnOthpconTblGuid
4854	{
4855	····PersistenceManager pm;
4856	····NDOMapping mapping;
4857	····Class ownClass;
4858	····Class otherClass;
4859	····Class otherDerivedClass;
4860	····[SetUp]
4861	····public void Setup()
4862	····{
4863	········this.pm = PmFactory.NewPersistenceManager();
4864	········this.mapping = pm.NDOMapping;
4865	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpconTblGuidLeft" );
4866	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpconTblGuidRightBase" );
4867	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpconTblGuidRightDerived" );
4868	····}
4869	····[Test]
4870	····public void HasMappingTable()
4871	····{
4872	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
4873	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
4874	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
4875	····}
4876	····[Test]
4877	····public void HasTypeColumn()
4878	····{
4879	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
4880	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
4881	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
4882	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
4883	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
4884	····}
4885	····[Test]
4886	····public void HasTypeCode()
4887	····{
4888	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4889	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4890	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4891	····}
4892	}
4893
4894
4895	[TestFixture]
4896	public class MappingTestCmpDir1OthpconNoTblGuid
4897	{
4898	····PersistenceManager pm;
4899	····NDOMapping mapping;
4900	····Class ownClass;
4901	····Class otherClass;
4902	····Class otherDerivedClass;
4903	····[SetUp]
4904	····public void Setup()
4905	····{
4906	········this.pm = PmFactory.NewPersistenceManager();
4907	········this.mapping = pm.NDOMapping;
4908	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconNoTblGuidLeft" );
4909	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconNoTblGuidRightBase" );
4910	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconNoTblGuidRightDerived" );
4911	····}
4912	····[Test]
4913	····public void HasMappingTable()
4914	····{
4915	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
4916	····}
4917	····[Test]
4918	····public void HasTypeColumn()
4919	····{
4920	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #9") ;
4921	····}
4922	····[Test]
4923	····public void HasTypeCode()
4924	····{
4925	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4926	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4927	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4928	····}
4929	}
4930
4931
4932	[TestFixture]
4933	public class MappingTestCmpDir1OthpconTblGuid
4934	{
4935	····PersistenceManager pm;
4936	····NDOMapping mapping;
4937	····Class ownClass;
4938	····Class otherClass;
4939	····Class otherDerivedClass;
4940	····[SetUp]
4941	····public void Setup()
4942	····{
4943	········this.pm = PmFactory.NewPersistenceManager();
4944	········this.mapping = pm.NDOMapping;
4945	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconTblGuidLeft" );
4946	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconTblGuidRightBase" );
4947	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconTblGuidRightDerived" );
4948	····}
4949	····[Test]
4950	····public void HasMappingTable()
4951	····{
4952	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
4953	····}
4954	····[Test]
4955	····public void HasTypeColumn()
4956	····{
4957	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
4958	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
4959	····}
4960	····[Test]
4961	····public void HasTypeCode()
4962	····{
4963	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4964	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4965	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4966	····}
4967	}
4968
4969
4970	[TestFixture]
4971	public class MappingTestCmpBi11OthpconNoTblGuid
4972	{
4973	····PersistenceManager pm;
4974	····NDOMapping mapping;
4975	····Class ownClass;
4976	····Class otherClass;
4977	····Class otherDerivedClass;
4978	····[SetUp]
4979	····public void Setup()
4980	····{
4981	········this.pm = PmFactory.NewPersistenceManager();
4982	········this.mapping = pm.NDOMapping;
4983	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconNoTblGuidLeft" );
4984	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconNoTblGuidRightBase" );
4985	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconNoTblGuidRightDerived" );
4986	····}
4987	····[Test]
4988	····public void HasMappingTable()
4989	····{
4990	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
4991	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
4992	Assert. Null( otherDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #8") ;
4993	····}
4994	····[Test]
4995	····public void HasTypeColumn()
4996	····{
4997	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #9") ;
4998	····}
4999	····[Test]
5000	····public void HasTypeCode()
5001	····{
5002	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5003	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5004	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5005	····}
5006	}
5007
5008
5009	[TestFixture]
5010	public class MappingTestCmpBi11OthpconTblGuid
5011	{
5012	····PersistenceManager pm;
5013	····NDOMapping mapping;
5014	····Class ownClass;
5015	····Class otherClass;
5016	····Class otherDerivedClass;
5017	····[SetUp]
5018	····public void Setup()
5019	····{
5020	········this.pm = PmFactory.NewPersistenceManager();
5021	········this.mapping = pm.NDOMapping;
5022	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconTblGuidLeft" );
5023	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconTblGuidRightBase" );
5024	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconTblGuidRightDerived" );
5025	····}
5026	····[Test]
5027	····public void HasMappingTable()
5028	····{
5029	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
5030	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
5031	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
5032	····}
5033	····[Test]
5034	····public void HasTypeColumn()
5035	····{
5036	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
5037	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
5038	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
5039	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
5040	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
5041	····}
5042	····[Test]
5043	····public void HasTypeCode()
5044	····{
5045	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5046	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5047	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5048	····}
5049	}
5050
5051
5052	[TestFixture]
5053	public class MappingTestCmpDirnOthpconTblGuid
5054	{
5055	····PersistenceManager pm;
5056	····NDOMapping mapping;
5057	····Class ownClass;
5058	····Class otherClass;
5059	····Class otherDerivedClass;
5060	····[SetUp]
5061	····public void Setup()
5062	····{
5063	········this.pm = PmFactory.NewPersistenceManager();
5064	········this.mapping = pm.NDOMapping;
5065	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpconTblGuidLeft" );
5066	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpconTblGuidRightBase" );
5067	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpconTblGuidRightDerived" );
5068	····}
5069	····[Test]
5070	····public void HasMappingTable()
5071	····{
5072	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
5073	····}
5074	····[Test]
5075	····public void HasTypeColumn()
5076	····{
5077	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
5078	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
5079	····}
5080	····[Test]
5081	····public void HasTypeCode()
5082	····{
5083	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5084	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5085	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5086	····}
5087	}
5088
5089
5090	[TestFixture]
5091	public class MappingTestCmpBin1OthpconTblGuid
5092	{
5093	····PersistenceManager pm;
5094	····NDOMapping mapping;
5095	····Class ownClass;
5096	····Class otherClass;
5097	····Class otherDerivedClass;
5098	····[SetUp]
5099	····public void Setup()
5100	····{
5101	········this.pm = PmFactory.NewPersistenceManager();
5102	········this.mapping = pm.NDOMapping;
5103	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpconTblGuidLeft" );
5104	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpconTblGuidRightBase" );
5105	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpconTblGuidRightDerived" );
5106	····}
5107	····[Test]
5108	····public void HasMappingTable()
5109	····{
5110	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
5111	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
5112	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
5113	····}
5114	····[Test]
5115	····public void HasTypeColumn()
5116	····{
5117	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
5118	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
5119	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
5120	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
5121	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
5122	····}
5123	····[Test]
5124	····public void HasTypeCode()
5125	····{
5126	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5127	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5128	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5129	····}
5130	}
5131
5132
5133	[TestFixture]
5134	public class MappingTestCmpBi1nOthpconNoTblGuid
5135	{
5136	····PersistenceManager pm;
5137	····NDOMapping mapping;
5138	····Class ownClass;
5139	····Class otherClass;
5140	····Class otherDerivedClass;
5141	····[SetUp]
5142	····public void Setup()
5143	····{
5144	········this.pm = PmFactory.NewPersistenceManager();
5145	········this.mapping = pm.NDOMapping;
5146	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconNoTblGuidLeft" );
5147	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconNoTblGuidRightBase" );
5148	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconNoTblGuidRightDerived" );
5149	····}
5150	····[Test]
5151	····public void HasMappingTable()
5152	····{
5153	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
5154	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
5155	Assert. Null( otherDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #8") ;
5156	····}
5157	····[Test]
5158	····public void HasTypeColumn()
5159	····{
5160	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #9") ;
5161	····}
5162	····[Test]
5163	····public void HasTypeCode()
5164	····{
5165	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5166	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5167	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5168	····}
5169	}
5170
5171
5172	[TestFixture]
5173	public class MappingTestCmpBi1nOthpconTblGuid
5174	{
5175	····PersistenceManager pm;
5176	····NDOMapping mapping;
5177	····Class ownClass;
5178	····Class otherClass;
5179	····Class otherDerivedClass;
5180	····[SetUp]
5181	····public void Setup()
5182	····{
5183	········this.pm = PmFactory.NewPersistenceManager();
5184	········this.mapping = pm.NDOMapping;
5185	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconTblGuidLeft" );
5186	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconTblGuidRightBase" );
5187	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconTblGuidRightDerived" );
5188	····}
5189	····[Test]
5190	····public void HasMappingTable()
5191	····{
5192	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
5193	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
5194	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
5195	····}
5196	····[Test]
5197	····public void HasTypeColumn()
5198	····{
5199	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
5200	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
5201	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
5202	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
5203	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
5204	····}
5205	····[Test]
5206	····public void HasTypeCode()
5207	····{
5208	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5209	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5210	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5211	····}
5212	}
5213
5214
5215	[TestFixture]
5216	public class MappingTestCmpBinnOthpconTblGuid
5217	{
5218	····PersistenceManager pm;
5219	····NDOMapping mapping;
5220	····Class ownClass;
5221	····Class otherClass;
5222	····Class otherDerivedClass;
5223	····[SetUp]
5224	····public void Setup()
5225	····{
5226	········this.pm = PmFactory.NewPersistenceManager();
5227	········this.mapping = pm.NDOMapping;
5228	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpconTblGuidLeft" );
5229	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpconTblGuidRightBase" );
5230	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpconTblGuidRightDerived" );
5231	····}
5232	····[Test]
5233	····public void HasMappingTable()
5234	····{
5235	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
5236	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
5237	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
5238	····}
5239	····[Test]
5240	····public void HasTypeColumn()
5241	····{
5242	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
5243	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
5244	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
5245	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
5246	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
5247	····}
5248	····[Test]
5249	····public void HasTypeCode()
5250	····{
5251	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5252	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5253	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5254	····}
5255	}
5256
5257
5258	[TestFixture]
5259	public class MappingTestAgrDir1OwnpconOthpconNoTblGuid
5260	{
5261	····PersistenceManager pm;
5262	····NDOMapping mapping;
5263	····Class ownClass;
5264	····Class otherClass;
5265	····Class ownDerivedClass;
5266	····Class otherDerivedClass;
5267	····[SetUp]
5268	····public void Setup()
5269	····{
5270	········this.pm = PmFactory.NewPersistenceManager();
5271	········this.mapping = pm.NDOMapping;
5272	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconNoTblGuidLeftBase" );
5273	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconNoTblGuidRightBase" );
5274	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconNoTblGuidLeftDerived" );
5275	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconNoTblGuidRightDerived" );
5276	····}
5277	····[Test]
5278	····public void HasMappingTable()
5279	····{
5280	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
5281	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
5282	····}
5283	····[Test]
5284	····public void HasTypeColumn()
5285	····{
5286	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #9") ;
5287	····}
5288	····[Test]
5289	····public void HasTypeCode()
5290	····{
5291	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5292	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5293	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5294	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5295	····}
5296	}
5297
5298
5299	[TestFixture]
5300	public class MappingTestAgrDir1OwnpconOthpconTblGuid
5301	{
5302	····PersistenceManager pm;
5303	····NDOMapping mapping;
5304	····Class ownClass;
5305	····Class otherClass;
5306	····Class ownDerivedClass;
5307	····Class otherDerivedClass;
5308	····[SetUp]
5309	····public void Setup()
5310	····{
5311	········this.pm = PmFactory.NewPersistenceManager();
5312	········this.mapping = pm.NDOMapping;
5313	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconTblGuidLeftBase" );
5314	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconTblGuidRightBase" );
5315	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconTblGuidLeftDerived" );
5316	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconTblGuidRightDerived" );
5317	····}
5318	····[Test]
5319	····public void HasMappingTable()
5320	····{
5321	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
5322	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
5323	····}
5324	····[Test]
5325	····public void HasTypeColumn()
5326	····{
5327	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
5328	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
5329	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
5330	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
5331	····}
5332	····[Test]
5333	····public void HasTypeCode()
5334	····{
5335	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5336	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5337	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5338	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5339	····}
5340	}
5341
5342
5343	[TestFixture]
5344	public class MappingTestAgrBi11OwnpconOthpconNoTblGuid
5345	{
5346	····PersistenceManager pm;
5347	····NDOMapping mapping;
5348	····Class ownClass;
5349	····Class otherClass;
5350	····Class ownDerivedClass;
5351	····Class otherDerivedClass;
5352	····[SetUp]
5353	····public void Setup()
5354	····{
5355	········this.pm = PmFactory.NewPersistenceManager();
5356	········this.mapping = pm.NDOMapping;
5357	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconNoTblGuidLeftBase" );
5358	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconNoTblGuidRightBase" );
5359	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconNoTblGuidLeftDerived" );
5360	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconNoTblGuidRightDerived" );
5361	····}
5362	····[Test]
5363	····public void HasMappingTable()
5364	····{
5365	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
5366	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
5367	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
5368	Assert. Null( otherDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #8") ;
5369	····}
5370	····[Test]
5371	····public void HasTypeColumn()
5372	····{
5373	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #9") ;
5374	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #10") ;
5375	····}
5376	····[Test]
5377	····public void HasTypeCode()
5378	····{
5379	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5380	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5381	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5382	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5383	····}
5384	}
5385
5386
5387	[TestFixture]
5388	public class MappingTestAgrBi11OwnpconOthpconTblGuid
5389	{
5390	····PersistenceManager pm;
5391	····NDOMapping mapping;
5392	····Class ownClass;
5393	····Class otherClass;
5394	····Class ownDerivedClass;
5395	····Class otherDerivedClass;
5396	····[SetUp]
5397	····public void Setup()
5398	····{
5399	········this.pm = PmFactory.NewPersistenceManager();
5400	········this.mapping = pm.NDOMapping;
5401	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconTblGuidLeftBase" );
5402	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconTblGuidRightBase" );
5403	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconTblGuidLeftDerived" );
5404	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconTblGuidRightDerived" );
5405	····}
5406	····[Test]
5407	····public void HasMappingTable()
5408	····{
5409	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
5410	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
5411	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
5412	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
5413	····}
5414	····[Test]
5415	····public void HasTypeColumn()
5416	····{
5417	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
5418	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
5419	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
5420	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
5421	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
5422	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
5423	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
5424	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #8") ;
5425	····}
5426	····[Test]
5427	····public void HasTypeCode()
5428	····{
5429	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5430	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5431	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5432	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5433	····}
5434	}
5435
5436
5437	[TestFixture]
5438	public class MappingTestAgrDirnOwnpconOthpconTblGuid
5439	{
5440	····PersistenceManager pm;
5441	····NDOMapping mapping;
5442	····Class ownClass;
5443	····Class otherClass;
5444	····Class ownDerivedClass;
5445	····Class otherDerivedClass;
5446	····[SetUp]
5447	····public void Setup()
5448	····{
5449	········this.pm = PmFactory.NewPersistenceManager();
5450	········this.mapping = pm.NDOMapping;
5451	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconOthpconTblGuidLeftBase" );
5452	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconOthpconTblGuidRightBase" );
5453	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconOthpconTblGuidLeftDerived" );
5454	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconOthpconTblGuidRightDerived" );
5455	····}
5456	····[Test]
5457	····public void HasMappingTable()
5458	····{
5459	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
5460	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
5461	····}
5462	····[Test]
5463	····public void HasTypeColumn()
5464	····{
5465	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
5466	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
5467	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
5468	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
5469	····}
5470	····[Test]
5471	····public void HasTypeCode()
5472	····{
5473	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5474	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5475	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5476	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5477	····}
5478	}
5479
5480
5481	[TestFixture]
5482	public class MappingTestAgrBin1OwnpconOthpconTblGuid
5483	{
5484	····PersistenceManager pm;
5485	····NDOMapping mapping;
5486	····Class ownClass;
5487	····Class otherClass;
5488	····Class ownDerivedClass;
5489	····Class otherDerivedClass;
5490	····[SetUp]
5491	····public void Setup()
5492	····{
5493	········this.pm = PmFactory.NewPersistenceManager();
5494	········this.mapping = pm.NDOMapping;
5495	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconOthpconTblGuidLeftBase" );
5496	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconOthpconTblGuidRightBase" );
5497	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconOthpconTblGuidLeftDerived" );
5498	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconOthpconTblGuidRightDerived" );
5499	····}
5500	····[Test]
5501	····public void HasMappingTable()
5502	····{
5503	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
5504	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
5505	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
5506	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
5507	····}
5508	····[Test]
5509	····public void HasTypeColumn()
5510	····{
5511	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
5512	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
5513	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
5514	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
5515	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
5516	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
5517	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
5518	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #8") ;
5519	····}
5520	····[Test]
5521	····public void HasTypeCode()
5522	····{
5523	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5524	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5525	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5526	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5527	····}
5528	}
5529
5530
5531	[TestFixture]
5532	public class MappingTestAgrBi1nOwnpconOthpconTblGuid
5533	{
5534	····PersistenceManager pm;
5535	····NDOMapping mapping;
5536	····Class ownClass;
5537	····Class otherClass;
5538	····Class ownDerivedClass;
5539	····Class otherDerivedClass;
5540	····[SetUp]
5541	····public void Setup()
5542	····{
5543	········this.pm = PmFactory.NewPersistenceManager();
5544	········this.mapping = pm.NDOMapping;
5545	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconOthpconTblGuidLeftBase" );
5546	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconOthpconTblGuidRightBase" );
5547	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconOthpconTblGuidLeftDerived" );
5548	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconOthpconTblGuidRightDerived" );
5549	····}
5550	····[Test]
5551	····public void HasMappingTable()
5552	····{
5553	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
5554	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
5555	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
5556	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
5557	····}
5558	····[Test]
5559	····public void HasTypeColumn()
5560	····{
5561	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
5562	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
5563	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
5564	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
5565	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
5566	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
5567	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
5568	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #8") ;
5569	····}
5570	····[Test]
5571	····public void HasTypeCode()
5572	····{
5573	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5574	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5575	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5576	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5577	····}
5578	}
5579
5580
5581	[TestFixture]
5582	public class MappingTestAgrBinnOwnpconOthpconTblGuid
5583	{
5584	····PersistenceManager pm;
5585	····NDOMapping mapping;
5586	····Class ownClass;
5587	····Class otherClass;
5588	····Class ownDerivedClass;
5589	····Class otherDerivedClass;
5590	····[SetUp]
5591	····public void Setup()
5592	····{
5593	········this.pm = PmFactory.NewPersistenceManager();
5594	········this.mapping = pm.NDOMapping;
5595	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconOthpconTblGuidLeftBase" );
5596	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconOthpconTblGuidRightBase" );
5597	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconOthpconTblGuidLeftDerived" );
5598	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconOthpconTblGuidRightDerived" );
5599	····}
5600	····[Test]
5601	····public void HasMappingTable()
5602	····{
5603	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
5604	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
5605	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
5606	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
5607	····}
5608	····[Test]
5609	····public void HasTypeColumn()
5610	····{
5611	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
5612	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
5613	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
5614	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
5615	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
5616	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
5617	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
5618	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #8") ;
5619	····}
5620	····[Test]
5621	····public void HasTypeCode()
5622	····{
5623	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5624	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5625	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5626	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5627	····}
5628	}
5629
5630
5631	[TestFixture]
5632	public class MappingTestCmpDir1OwnpconOthpconNoTblGuid
5633	{
5634	····PersistenceManager pm;
5635	····NDOMapping mapping;
5636	····Class ownClass;
5637	····Class otherClass;
5638	····Class ownDerivedClass;
5639	····Class otherDerivedClass;
5640	····[SetUp]
5641	····public void Setup()
5642	····{
5643	········this.pm = PmFactory.NewPersistenceManager();
5644	········this.mapping = pm.NDOMapping;
5645	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconNoTblGuidLeftBase" );
5646	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconNoTblGuidRightBase" );
5647	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconNoTblGuidLeftDerived" );
5648	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconNoTblGuidRightDerived" );
5649	····}
5650	····[Test]
5651	····public void HasMappingTable()
5652	····{
5653	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
5654	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
5655	····}
5656	····[Test]
5657	····public void HasTypeColumn()
5658	····{
5659	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #9") ;
5660	····}
5661	····[Test]
5662	····public void HasTypeCode()
5663	····{
5664	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5665	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5666	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5667	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5668	····}
5669	}
5670
5671
5672	[TestFixture]
5673	public class MappingTestCmpDir1OwnpconOthpconTblGuid
5674	{
5675	····PersistenceManager pm;
5676	····NDOMapping mapping;
5677	····Class ownClass;
5678	····Class otherClass;
5679	····Class ownDerivedClass;
5680	····Class otherDerivedClass;
5681	····[SetUp]
5682	····public void Setup()
5683	····{
5684	········this.pm = PmFactory.NewPersistenceManager();
5685	········this.mapping = pm.NDOMapping;
5686	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconTblGuidLeftBase" );
5687	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconTblGuidRightBase" );
5688	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconTblGuidLeftDerived" );
5689	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconTblGuidRightDerived" );
5690	····}
5691	····[Test]
5692	····public void HasMappingTable()
5693	····{
5694	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
5695	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
5696	····}
5697	····[Test]
5698	····public void HasTypeColumn()
5699	····{
5700	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
5701	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
5702	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
5703	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
5704	····}
5705	····[Test]
5706	····public void HasTypeCode()
5707	····{
5708	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5709	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5710	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5711	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5712	····}
5713	}
5714
5715
5716	[TestFixture]
5717	public class MappingTestCmpBi11OwnpconOthpconNoTblGuid
5718	{
5719	····PersistenceManager pm;
5720	····NDOMapping mapping;
5721	····Class ownClass;
5722	····Class otherClass;
5723	····Class ownDerivedClass;
5724	····Class otherDerivedClass;
5725	····[SetUp]
5726	····public void Setup()
5727	····{
5728	········this.pm = PmFactory.NewPersistenceManager();
5729	········this.mapping = pm.NDOMapping;
5730	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconNoTblGuidLeftBase" );
5731	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconNoTblGuidRightBase" );
5732	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconNoTblGuidLeftDerived" );
5733	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconNoTblGuidRightDerived" );
5734	····}
5735	····[Test]
5736	····public void HasMappingTable()
5737	····{
5738	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
5739	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
5740	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
5741	Assert. Null( otherDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #8") ;
5742	····}
5743	····[Test]
5744	····public void HasTypeColumn()
5745	····{
5746	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #9") ;
5747	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #10") ;
5748	····}
5749	····[Test]
5750	····public void HasTypeCode()
5751	····{
5752	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5753	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5754	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5755	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5756	····}
5757	}
5758
5759
5760	[TestFixture]
5761	public class MappingTestCmpBi11OwnpconOthpconTblGuid
5762	{
5763	····PersistenceManager pm;
5764	····NDOMapping mapping;
5765	····Class ownClass;
5766	····Class otherClass;
5767	····Class ownDerivedClass;
5768	····Class otherDerivedClass;
5769	····[SetUp]
5770	····public void Setup()
5771	····{
5772	········this.pm = PmFactory.NewPersistenceManager();
5773	········this.mapping = pm.NDOMapping;
5774	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconTblGuidLeftBase" );
5775	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconTblGuidRightBase" );
5776	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconTblGuidLeftDerived" );
5777	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconTblGuidRightDerived" );
5778	····}
5779	····[Test]
5780	····public void HasMappingTable()
5781	····{
5782	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
5783	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
5784	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
5785	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
5786	····}
5787	····[Test]
5788	····public void HasTypeColumn()
5789	····{
5790	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
5791	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
5792	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
5793	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
5794	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
5795	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
5796	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
5797	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #8") ;
5798	····}
5799	····[Test]
5800	····public void HasTypeCode()
5801	····{
5802	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5803	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5804	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5805	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5806	····}
5807	}
5808
5809
5810	[TestFixture]
5811	public class MappingTestCmpDirnOwnpconOthpconTblGuid
5812	{
5813	····PersistenceManager pm;
5814	····NDOMapping mapping;
5815	····Class ownClass;
5816	····Class otherClass;
5817	····Class ownDerivedClass;
5818	····Class otherDerivedClass;
5819	····[SetUp]
5820	····public void Setup()
5821	····{
5822	········this.pm = PmFactory.NewPersistenceManager();
5823	········this.mapping = pm.NDOMapping;
5824	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconOthpconTblGuidLeftBase" );
5825	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconOthpconTblGuidRightBase" );
5826	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconOthpconTblGuidLeftDerived" );
5827	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconOthpconTblGuidRightDerived" );
5828	····}
5829	····[Test]
5830	····public void HasMappingTable()
5831	····{
5832	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
5833	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
5834	····}
5835	····[Test]
5836	····public void HasTypeColumn()
5837	····{
5838	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
5839	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
5840	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
5841	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
5842	····}
5843	····[Test]
5844	····public void HasTypeCode()
5845	····{
5846	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5847	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5848	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5849	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5850	····}
5851	}
5852
5853
5854	[TestFixture]
5855	public class MappingTestCmpBin1OwnpconOthpconTblGuid
5856	{
5857	····PersistenceManager pm;
5858	····NDOMapping mapping;
5859	····Class ownClass;
5860	····Class otherClass;
5861	····Class ownDerivedClass;
5862	····Class otherDerivedClass;
5863	····[SetUp]
5864	····public void Setup()
5865	····{
5866	········this.pm = PmFactory.NewPersistenceManager();
5867	········this.mapping = pm.NDOMapping;
5868	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconOthpconTblGuidLeftBase" );
5869	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconOthpconTblGuidRightBase" );
5870	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconOthpconTblGuidLeftDerived" );
5871	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconOthpconTblGuidRightDerived" );
5872	····}
5873	····[Test]
5874	····public void HasMappingTable()
5875	····{
5876	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
5877	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
5878	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
5879	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
5880	····}
5881	····[Test]
5882	····public void HasTypeColumn()
5883	····{
5884	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
5885	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
5886	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
5887	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
5888	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
5889	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
5890	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
5891	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #8") ;
5892	····}
5893	····[Test]
5894	····public void HasTypeCode()
5895	····{
5896	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5897	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5898	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5899	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5900	····}
5901	}
5902
5903
5904	[TestFixture]
5905	public class MappingTestCmpBi1nOwnpconOthpconTblGuid
5906	{
5907	····PersistenceManager pm;
5908	····NDOMapping mapping;
5909	····Class ownClass;
5910	····Class otherClass;
5911	····Class ownDerivedClass;
5912	····Class otherDerivedClass;
5913	····[SetUp]
5914	····public void Setup()
5915	····{
5916	········this.pm = PmFactory.NewPersistenceManager();
5917	········this.mapping = pm.NDOMapping;
5918	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconOthpconTblGuidLeftBase" );
5919	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconOthpconTblGuidRightBase" );
5920	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconOthpconTblGuidLeftDerived" );
5921	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconOthpconTblGuidRightDerived" );
5922	····}
5923	····[Test]
5924	····public void HasMappingTable()
5925	····{
5926	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
5927	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
5928	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
5929	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
5930	····}
5931	····[Test]
5932	····public void HasTypeColumn()
5933	····{
5934	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
5935	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
5936	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
5937	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
5938	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
5939	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
5940	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
5941	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #8") ;
5942	····}
5943	····[Test]
5944	····public void HasTypeCode()
5945	····{
5946	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5947	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5948	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5949	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5950	····}
5951	}
5952
5953
5954	[TestFixture]
5955	public class MappingTestCmpBinnOwnpconOthpconTblGuid
5956	{
5957	····PersistenceManager pm;
5958	····NDOMapping mapping;
5959	····Class ownClass;
5960	····Class otherClass;
5961	····Class ownDerivedClass;
5962	····Class otherDerivedClass;
5963	····[SetUp]
5964	····public void Setup()
5965	····{
5966	········this.pm = PmFactory.NewPersistenceManager();
5967	········this.mapping = pm.NDOMapping;
5968	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconOthpconTblGuidLeftBase" );
5969	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconOthpconTblGuidRightBase" );
5970	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconOthpconTblGuidLeftDerived" );
5971	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconOthpconTblGuidRightDerived" );
5972	····}
5973	····[Test]
5974	····public void HasMappingTable()
5975	····{
5976	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
5977	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
5978	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
5979	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
5980	····}
5981	····[Test]
5982	····public void HasTypeColumn()
5983	····{
5984	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
5985	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
5986	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
5987	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
5988	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
5989	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
5990	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
5991	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #8") ;
5992	····}
5993	····[Test]
5994	····public void HasTypeCode()
5995	····{
5996	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5997	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5998	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5999	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
6000	····}
6001	}
6002
6003
6004	[TestFixture]
6005	public class MappingTestAgrDir1OwnpabsNoTblAuto
6006	{
6007	····PersistenceManager pm;
6008	····NDOMapping mapping;
6009	····Class ownClass;
6010	····Class otherClass;
6011	····Class ownDerivedClass;
6012	····[SetUp]
6013	····public void Setup()
6014	····{
6015	········this.pm = PmFactory.NewPersistenceManager();
6016	········this.mapping = pm.NDOMapping;
6017	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsNoTblAutoLeftBase" );
6018	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsNoTblAutoRight" );
6019	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsNoTblAutoLeftDerived" );
6020	····}
6021	····[Test]
6022	····public void HasMappingTable()
6023	····{
6024	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
6025	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
6026	····}
6027	····[Test]
6028	····public void HasTypeColumn()
6029	····{
6030	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
6031	····}
6032	····[Test]
6033	····public void HasTypeCode()
6034	····{
6035	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6036	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6037	····}
6038	}
6039
6040
6041	[TestFixture]
6042	public class MappingTestAgrDir1OwnpabsTblAuto
6043	{
6044	····PersistenceManager pm;
6045	····NDOMapping mapping;
6046	····Class ownClass;
6047	····Class otherClass;
6048	····Class ownDerivedClass;
6049	····[SetUp]
6050	····public void Setup()
6051	····{
6052	········this.pm = PmFactory.NewPersistenceManager();
6053	········this.mapping = pm.NDOMapping;
6054	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsTblAutoLeftBase" );
6055	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsTblAutoRight" );
6056	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsTblAutoLeftDerived" );
6057	····}
6058	····[Test]
6059	····public void HasMappingTable()
6060	····{
6061	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
6062	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
6063	····}
6064	····[Test]
6065	····public void HasTypeColumn()
6066	····{
6067	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
6068	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
6069	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
6070	····}
6071	····[Test]
6072	····public void HasTypeCode()
6073	····{
6074	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6075	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6076	····}
6077	}
6078
6079
6080	[TestFixture]
6081	public class MappingTestAgrBi11OwnpabsNoTblAuto
6082	{
6083	····PersistenceManager pm;
6084	····NDOMapping mapping;
6085	····Class ownClass;
6086	····Class otherClass;
6087	····Class ownDerivedClass;
6088	····[SetUp]
6089	····public void Setup()
6090	····{
6091	········this.pm = PmFactory.NewPersistenceManager();
6092	········this.mapping = pm.NDOMapping;
6093	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsNoTblAutoLeftBase" );
6094	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsNoTblAutoRight" );
6095	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsNoTblAutoLeftDerived" );
6096	····}
6097	····[Test]
6098	····public void HasMappingTable()
6099	····{
6100	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
6101	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
6102	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
6103	····}
6104	····[Test]
6105	····public void HasTypeColumn()
6106	····{
6107	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
6108	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #10") ;
6109	····}
6110	····[Test]
6111	····public void HasTypeCode()
6112	····{
6113	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6114	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6115	····}
6116	}
6117
6118
6119	[TestFixture]
6120	public class MappingTestAgrBi11OwnpabsTblAuto
6121	{
6122	····PersistenceManager pm;
6123	····NDOMapping mapping;
6124	····Class ownClass;
6125	····Class otherClass;
6126	····Class ownDerivedClass;
6127	····[SetUp]
6128	····public void Setup()
6129	····{
6130	········this.pm = PmFactory.NewPersistenceManager();
6131	········this.mapping = pm.NDOMapping;
6132	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsTblAutoLeftBase" );
6133	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsTblAutoRight" );
6134	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsTblAutoLeftDerived" );
6135	····}
6136	····[Test]
6137	····public void HasMappingTable()
6138	····{
6139	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
6140	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
6141	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
6142	····}
6143	····[Test]
6144	····public void HasTypeColumn()
6145	····{
6146	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
6147	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
6148	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
6149	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
6150	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
6151	····}
6152	····[Test]
6153	····public void HasTypeCode()
6154	····{
6155	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6156	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6157	····}
6158	}
6159
6160
6161	[TestFixture]
6162	public class MappingTestAgrDirnOwnpabsNoTblAuto
6163	{
6164	····PersistenceManager pm;
6165	····NDOMapping mapping;
6166	····Class ownClass;
6167	····Class otherClass;
6168	····Class ownDerivedClass;
6169	····[SetUp]
6170	····public void Setup()
6171	····{
6172	········this.pm = PmFactory.NewPersistenceManager();
6173	········this.mapping = pm.NDOMapping;
6174	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsNoTblAutoLeftBase" );
6175	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsNoTblAutoRight" );
6176	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsNoTblAutoLeftDerived" );
6177	····}
6178	····[Test]
6179	····public void HasMappingTable()
6180	····{
6181	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
6182	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
6183	····}
6184	····[Test]
6185	····public void HasTypeColumn()
6186	····{
6187	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
6188	····}
6189	····[Test]
6190	····public void HasTypeCode()
6191	····{
6192	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6193	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6194	····}
6195	}
6196
6197
6198	[TestFixture]
6199	public class MappingTestAgrDirnOwnpabsTblAuto
6200	{
6201	····PersistenceManager pm;
6202	····NDOMapping mapping;
6203	····Class ownClass;
6204	····Class otherClass;
6205	····Class ownDerivedClass;
6206	····[SetUp]
6207	····public void Setup()
6208	····{
6209	········this.pm = PmFactory.NewPersistenceManager();
6210	········this.mapping = pm.NDOMapping;
6211	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsTblAutoLeftBase" );
6212	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsTblAutoRight" );
6213	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsTblAutoLeftDerived" );
6214	····}
6215	····[Test]
6216	····public void HasMappingTable()
6217	····{
6218	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
6219	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
6220	····}
6221	····[Test]
6222	····public void HasTypeColumn()
6223	····{
6224	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
6225	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
6226	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
6227	····}
6228	····[Test]
6229	····public void HasTypeCode()
6230	····{
6231	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6232	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6233	····}
6234	}
6235
6236
6237	[TestFixture]
6238	public class MappingTestAgrBin1OwnpabsNoTblAuto
6239	{
6240	····PersistenceManager pm;
6241	····NDOMapping mapping;
6242	····Class ownClass;
6243	····Class otherClass;
6244	····Class ownDerivedClass;
6245	····[SetUp]
6246	····public void Setup()
6247	····{
6248	········this.pm = PmFactory.NewPersistenceManager();
6249	········this.mapping = pm.NDOMapping;
6250	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsNoTblAutoLeftBase" );
6251	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsNoTblAutoRight" );
6252	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsNoTblAutoLeftDerived" );
6253	····}
6254	····[Test]
6255	····public void HasMappingTable()
6256	····{
6257	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
6258	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
6259	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
6260	····}
6261	····[Test]
6262	····public void HasTypeColumn()
6263	····{
6264	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
6265	····}
6266	····[Test]
6267	····public void HasTypeCode()
6268	····{
6269	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6270	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6271	····}
6272	}
6273
6274
6275	[TestFixture]
6276	public class MappingTestAgrBin1OwnpabsTblAuto
6277	{
6278	····PersistenceManager pm;
6279	····NDOMapping mapping;
6280	····Class ownClass;
6281	····Class otherClass;
6282	····Class ownDerivedClass;
6283	····[SetUp]
6284	····public void Setup()
6285	····{
6286	········this.pm = PmFactory.NewPersistenceManager();
6287	········this.mapping = pm.NDOMapping;
6288	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsTblAutoLeftBase" );
6289	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsTblAutoRight" );
6290	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsTblAutoLeftDerived" );
6291	····}
6292	····[Test]
6293	····public void HasMappingTable()
6294	····{
6295	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
6296	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
6297	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
6298	····}
6299	····[Test]
6300	····public void HasTypeColumn()
6301	····{
6302	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
6303	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
6304	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
6305	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
6306	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
6307	····}
6308	····[Test]
6309	····public void HasTypeCode()
6310	····{
6311	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6312	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6313	····}
6314	}
6315
6316
6317	[TestFixture]
6318	public class MappingTestAgrBi1nOwnpabsTblAuto
6319	{
6320	····PersistenceManager pm;
6321	····NDOMapping mapping;
6322	····Class ownClass;
6323	····Class otherClass;
6324	····Class ownDerivedClass;
6325	····[SetUp]
6326	····public void Setup()
6327	····{
6328	········this.pm = PmFactory.NewPersistenceManager();
6329	········this.mapping = pm.NDOMapping;
6330	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsTblAutoLeftBase" );
6331	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsTblAutoRight" );
6332	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsTblAutoLeftDerived" );
6333	····}
6334	····[Test]
6335	····public void HasMappingTable()
6336	····{
6337	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
6338	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
6339	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
6340	····}
6341	····[Test]
6342	····public void HasTypeColumn()
6343	····{
6344	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
6345	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
6346	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
6347	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
6348	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
6349	····}
6350	····[Test]
6351	····public void HasTypeCode()
6352	····{
6353	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6354	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6355	····}
6356	}
6357
6358
6359	[TestFixture]
6360	public class MappingTestAgrBinnOwnpabsTblAuto
6361	{
6362	····PersistenceManager pm;
6363	····NDOMapping mapping;
6364	····Class ownClass;
6365	····Class otherClass;
6366	····Class ownDerivedClass;
6367	····[SetUp]
6368	····public void Setup()
6369	····{
6370	········this.pm = PmFactory.NewPersistenceManager();
6371	········this.mapping = pm.NDOMapping;
6372	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsTblAutoLeftBase" );
6373	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsTblAutoRight" );
6374	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsTblAutoLeftDerived" );
6375	····}
6376	····[Test]
6377	····public void HasMappingTable()
6378	····{
6379	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
6380	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
6381	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
6382	····}
6383	····[Test]
6384	····public void HasTypeColumn()
6385	····{
6386	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
6387	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
6388	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
6389	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
6390	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
6391	····}
6392	····[Test]
6393	····public void HasTypeCode()
6394	····{
6395	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6396	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6397	····}
6398	}
6399
6400
6401	[TestFixture]
6402	public class MappingTestCmpDir1OwnpabsNoTblAuto
6403	{
6404	····PersistenceManager pm;
6405	····NDOMapping mapping;
6406	····Class ownClass;
6407	····Class otherClass;
6408	····Class ownDerivedClass;
6409	····[SetUp]
6410	····public void Setup()
6411	····{
6412	········this.pm = PmFactory.NewPersistenceManager();
6413	········this.mapping = pm.NDOMapping;
6414	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsNoTblAutoLeftBase" );
6415	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsNoTblAutoRight" );
6416	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsNoTblAutoLeftDerived" );
6417	····}
6418	····[Test]
6419	····public void HasMappingTable()
6420	····{
6421	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
6422	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
6423	····}
6424	····[Test]
6425	····public void HasTypeColumn()
6426	····{
6427	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
6428	····}
6429	····[Test]
6430	····public void HasTypeCode()
6431	····{
6432	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6433	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6434	····}
6435	}
6436
6437
6438	[TestFixture]
6439	public class MappingTestCmpDir1OwnpabsTblAuto
6440	{
6441	····PersistenceManager pm;
6442	····NDOMapping mapping;
6443	····Class ownClass;
6444	····Class otherClass;
6445	····Class ownDerivedClass;
6446	····[SetUp]
6447	····public void Setup()
6448	····{
6449	········this.pm = PmFactory.NewPersistenceManager();
6450	········this.mapping = pm.NDOMapping;
6451	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsTblAutoLeftBase" );
6452	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsTblAutoRight" );
6453	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsTblAutoLeftDerived" );
6454	····}
6455	····[Test]
6456	····public void HasMappingTable()
6457	····{
6458	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
6459	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
6460	····}
6461	····[Test]
6462	····public void HasTypeColumn()
6463	····{
6464	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
6465	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
6466	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
6467	····}
6468	····[Test]
6469	····public void HasTypeCode()
6470	····{
6471	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6472	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6473	····}
6474	}
6475
6476
6477	[TestFixture]
6478	public class MappingTestCmpBi11OwnpabsNoTblAuto
6479	{
6480	····PersistenceManager pm;
6481	····NDOMapping mapping;
6482	····Class ownClass;
6483	····Class otherClass;
6484	····Class ownDerivedClass;
6485	····[SetUp]
6486	····public void Setup()
6487	····{
6488	········this.pm = PmFactory.NewPersistenceManager();
6489	········this.mapping = pm.NDOMapping;
6490	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsNoTblAutoLeftBase" );
6491	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsNoTblAutoRight" );
6492	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsNoTblAutoLeftDerived" );
6493	····}
6494	····[Test]
6495	····public void HasMappingTable()
6496	····{
6497	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
6498	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
6499	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
6500	····}
6501	····[Test]
6502	····public void HasTypeColumn()
6503	····{
6504	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
6505	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #10") ;
6506	····}
6507	····[Test]
6508	····public void HasTypeCode()
6509	····{
6510	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6511	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6512	····}
6513	}
6514
6515
6516	[TestFixture]
6517	public class MappingTestCmpBi11OwnpabsTblAuto
6518	{
6519	····PersistenceManager pm;
6520	····NDOMapping mapping;
6521	····Class ownClass;
6522	····Class otherClass;
6523	····Class ownDerivedClass;
6524	····[SetUp]
6525	····public void Setup()
6526	····{
6527	········this.pm = PmFactory.NewPersistenceManager();
6528	········this.mapping = pm.NDOMapping;
6529	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsTblAutoLeftBase" );
6530	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsTblAutoRight" );
6531	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsTblAutoLeftDerived" );
6532	····}
6533	····[Test]
6534	····public void HasMappingTable()
6535	····{
6536	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
6537	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
6538	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
6539	····}
6540	····[Test]
6541	····public void HasTypeColumn()
6542	····{
6543	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
6544	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
6545	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
6546	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
6547	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
6548	····}
6549	····[Test]
6550	····public void HasTypeCode()
6551	····{
6552	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6553	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6554	····}
6555	}
6556
6557
6558	[TestFixture]
6559	public class MappingTestCmpDirnOwnpabsNoTblAuto
6560	{
6561	····PersistenceManager pm;
6562	····NDOMapping mapping;
6563	····Class ownClass;
6564	····Class otherClass;
6565	····Class ownDerivedClass;
6566	····[SetUp]
6567	····public void Setup()
6568	····{
6569	········this.pm = PmFactory.NewPersistenceManager();
6570	········this.mapping = pm.NDOMapping;
6571	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsNoTblAutoLeftBase" );
6572	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsNoTblAutoRight" );
6573	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsNoTblAutoLeftDerived" );
6574	····}
6575	····[Test]
6576	····public void HasMappingTable()
6577	····{
6578	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
6579	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
6580	····}
6581	····[Test]
6582	····public void HasTypeColumn()
6583	····{
6584	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
6585	····}
6586	····[Test]
6587	····public void HasTypeCode()
6588	····{
6589	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6590	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6591	····}
6592	}
6593
6594
6595	[TestFixture]
6596	public class MappingTestCmpDirnOwnpabsTblAuto
6597	{
6598	····PersistenceManager pm;
6599	····NDOMapping mapping;
6600	····Class ownClass;
6601	····Class otherClass;
6602	····Class ownDerivedClass;
6603	····[SetUp]
6604	····public void Setup()
6605	····{
6606	········this.pm = PmFactory.NewPersistenceManager();
6607	········this.mapping = pm.NDOMapping;
6608	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsTblAutoLeftBase" );
6609	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsTblAutoRight" );
6610	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsTblAutoLeftDerived" );
6611	····}
6612	····[Test]
6613	····public void HasMappingTable()
6614	····{
6615	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
6616	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
6617	····}
6618	····[Test]
6619	····public void HasTypeColumn()
6620	····{
6621	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
6622	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
6623	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
6624	····}
6625	····[Test]
6626	····public void HasTypeCode()
6627	····{
6628	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6629	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6630	····}
6631	}
6632
6633
6634	[TestFixture]
6635	public class MappingTestCmpBin1OwnpabsNoTblAuto
6636	{
6637	····PersistenceManager pm;
6638	····NDOMapping mapping;
6639	····Class ownClass;
6640	····Class otherClass;
6641	····Class ownDerivedClass;
6642	····[SetUp]
6643	····public void Setup()
6644	····{
6645	········this.pm = PmFactory.NewPersistenceManager();
6646	········this.mapping = pm.NDOMapping;
6647	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsNoTblAutoLeftBase" );
6648	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsNoTblAutoRight" );
6649	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsNoTblAutoLeftDerived" );
6650	····}
6651	····[Test]
6652	····public void HasMappingTable()
6653	····{
6654	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
6655	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
6656	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
6657	····}
6658	····[Test]
6659	····public void HasTypeColumn()
6660	····{
6661	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
6662	····}
6663	····[Test]
6664	····public void HasTypeCode()
6665	····{
6666	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6667	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6668	····}
6669	}
6670
6671
6672	[TestFixture]
6673	public class MappingTestCmpBin1OwnpabsTblAuto
6674	{
6675	····PersistenceManager pm;
6676	····NDOMapping mapping;
6677	····Class ownClass;
6678	····Class otherClass;
6679	····Class ownDerivedClass;
6680	····[SetUp]
6681	····public void Setup()
6682	····{
6683	········this.pm = PmFactory.NewPersistenceManager();
6684	········this.mapping = pm.NDOMapping;
6685	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsTblAutoLeftBase" );
6686	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsTblAutoRight" );
6687	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsTblAutoLeftDerived" );
6688	····}
6689	····[Test]
6690	····public void HasMappingTable()
6691	····{
6692	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
6693	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
6694	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
6695	····}
6696	····[Test]
6697	····public void HasTypeColumn()
6698	····{
6699	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
6700	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
6701	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
6702	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
6703	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
6704	····}
6705	····[Test]
6706	····public void HasTypeCode()
6707	····{
6708	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6709	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6710	····}
6711	}
6712
6713
6714	[TestFixture]
6715	public class MappingTestCmpBi1nOwnpabsTblAuto
6716	{
6717	····PersistenceManager pm;
6718	····NDOMapping mapping;
6719	····Class ownClass;
6720	····Class otherClass;
6721	····Class ownDerivedClass;
6722	····[SetUp]
6723	····public void Setup()
6724	····{
6725	········this.pm = PmFactory.NewPersistenceManager();
6726	········this.mapping = pm.NDOMapping;
6727	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsTblAutoLeftBase" );
6728	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsTblAutoRight" );
6729	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsTblAutoLeftDerived" );
6730	····}
6731	····[Test]
6732	····public void HasMappingTable()
6733	····{
6734	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
6735	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
6736	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
6737	····}
6738	····[Test]
6739	····public void HasTypeColumn()
6740	····{
6741	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
6742	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
6743	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
6744	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
6745	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
6746	····}
6747	····[Test]
6748	····public void HasTypeCode()
6749	····{
6750	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6751	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6752	····}
6753	}
6754
6755
6756	[TestFixture]
6757	public class MappingTestCmpBinnOwnpabsTblAuto
6758	{
6759	····PersistenceManager pm;
6760	····NDOMapping mapping;
6761	····Class ownClass;
6762	····Class otherClass;
6763	····Class ownDerivedClass;
6764	····[SetUp]
6765	····public void Setup()
6766	····{
6767	········this.pm = PmFactory.NewPersistenceManager();
6768	········this.mapping = pm.NDOMapping;
6769	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsTblAutoLeftBase" );
6770	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsTblAutoRight" );
6771	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsTblAutoLeftDerived" );
6772	····}
6773	····[Test]
6774	····public void HasMappingTable()
6775	····{
6776	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
6777	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
6778	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
6779	····}
6780	····[Test]
6781	····public void HasTypeColumn()
6782	····{
6783	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
6784	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
6785	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
6786	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
6787	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
6788	····}
6789	····[Test]
6790	····public void HasTypeCode()
6791	····{
6792	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6793	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6794	····}
6795	}
6796
6797
6798	[TestFixture]
6799	public class MappingTestAgrDir1OthpabsNoTblAuto
6800	{
6801	····PersistenceManager pm;
6802	····NDOMapping mapping;
6803	····Class ownClass;
6804	····Class otherClass;
6805	····Class otherDerivedClass;
6806	····[SetUp]
6807	····public void Setup()
6808	····{
6809	········this.pm = PmFactory.NewPersistenceManager();
6810	········this.mapping = pm.NDOMapping;
6811	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsNoTblAutoLeft" );
6812	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsNoTblAutoRightBase" );
6813	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsNoTblAutoRightDerived" );
6814	····}
6815	····[Test]
6816	····public void HasMappingTable()
6817	····{
6818	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
6819	····}
6820	····[Test]
6821	····public void HasTypeColumn()
6822	····{
6823	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #9") ;
6824	····}
6825	····[Test]
6826	····public void HasTypeCode()
6827	····{
6828	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
6829	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
6830	····}
6831	}
6832
6833
6834	[TestFixture]
6835	public class MappingTestAgrDir1OthpabsTblAuto
6836	{
6837	····PersistenceManager pm;
6838	····NDOMapping mapping;
6839	····Class ownClass;
6840	····Class otherClass;
6841	····Class otherDerivedClass;
6842	····[SetUp]
6843	····public void Setup()
6844	····{
6845	········this.pm = PmFactory.NewPersistenceManager();
6846	········this.mapping = pm.NDOMapping;
6847	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsTblAutoLeft" );
6848	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsTblAutoRightBase" );
6849	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsTblAutoRightDerived" );
6850	····}
6851	····[Test]
6852	····public void HasMappingTable()
6853	····{
6854	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
6855	····}
6856	····[Test]
6857	····public void HasTypeColumn()
6858	····{
6859	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
6860	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
6861	····}
6862	····[Test]
6863	····public void HasTypeCode()
6864	····{
6865	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
6866	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
6867	····}
6868	}
6869
6870
6871	[TestFixture]
6872	public class MappingTestAgrBi11OthpabsNoTblAuto
6873	{
6874	····PersistenceManager pm;
6875	····NDOMapping mapping;
6876	····Class ownClass;
6877	····Class otherClass;
6878	····Class otherDerivedClass;
6879	····[SetUp]
6880	····public void Setup()
6881	····{
6882	········this.pm = PmFactory.NewPersistenceManager();
6883	········this.mapping = pm.NDOMapping;
6884	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsNoTblAutoLeft" );
6885	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsNoTblAutoRightBase" );
6886	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsNoTblAutoRightDerived" );
6887	····}
6888	····[Test]
6889	····public void HasMappingTable()
6890	····{
6891	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
6892	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
6893	Assert. Null( otherDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #8") ;
6894	····}
6895	····[Test]
6896	····public void HasTypeColumn()
6897	····{
6898	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #9") ;
6899	····}
6900	····[Test]
6901	····public void HasTypeCode()
6902	····{
6903	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
6904	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
6905	····}
6906	}
6907
6908
6909	[TestFixture]
6910	public class MappingTestAgrBi11OthpabsTblAuto
6911	{
6912	····PersistenceManager pm;
6913	····NDOMapping mapping;
6914	····Class ownClass;
6915	····Class otherClass;
6916	····Class otherDerivedClass;
6917	····[SetUp]
6918	····public void Setup()
6919	····{
6920	········this.pm = PmFactory.NewPersistenceManager();
6921	········this.mapping = pm.NDOMapping;
6922	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsTblAutoLeft" );
6923	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsTblAutoRightBase" );
6924	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsTblAutoRightDerived" );
6925	····}
6926	····[Test]
6927	····public void HasMappingTable()
6928	····{
6929	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
6930	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
6931	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
6932	····}
6933	····[Test]
6934	····public void HasTypeColumn()
6935	····{
6936	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
6937	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
6938	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
6939	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
6940	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
6941	····}
6942	····[Test]
6943	····public void HasTypeCode()
6944	····{
6945	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
6946	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
6947	····}
6948	}
6949
6950
6951	[TestFixture]
6952	public class MappingTestAgrDirnOthpabsTblAuto
6953	{
6954	····PersistenceManager pm;
6955	····NDOMapping mapping;
6956	····Class ownClass;
6957	····Class otherClass;
6958	····Class otherDerivedClass;
6959	····[SetUp]
6960	····public void Setup()
6961	····{
6962	········this.pm = PmFactory.NewPersistenceManager();
6963	········this.mapping = pm.NDOMapping;
6964	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpabsTblAutoLeft" );
6965	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpabsTblAutoRightBase" );
6966	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpabsTblAutoRightDerived" );
6967	····}
6968	····[Test]
6969	····public void HasMappingTable()
6970	····{
6971	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
6972	····}
6973	····[Test]
6974	····public void HasTypeColumn()
6975	····{
6976	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
6977	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
6978	····}
6979	····[Test]
6980	····public void HasTypeCode()
6981	····{
6982	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
6983	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
6984	····}
6985	}
6986
6987
6988	[TestFixture]
6989	public class MappingTestAgrBin1OthpabsTblAuto
6990	{
6991	····PersistenceManager pm;
6992	····NDOMapping mapping;
6993	····Class ownClass;
6994	····Class otherClass;
6995	····Class otherDerivedClass;
6996	····[SetUp]
6997	····public void Setup()
6998	····{
6999	········this.pm = PmFactory.NewPersistenceManager();
7000	········this.mapping = pm.NDOMapping;
7001	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpabsTblAutoLeft" );
7002	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpabsTblAutoRightBase" );
7003	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpabsTblAutoRightDerived" );
7004	····}
7005	····[Test]
7006	····public void HasMappingTable()
7007	····{
7008	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
7009	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
7010	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
7011	····}
7012	····[Test]
7013	····public void HasTypeColumn()
7014	····{
7015	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
7016	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
7017	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
7018	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
7019	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
7020	····}
7021	····[Test]
7022	····public void HasTypeCode()
7023	····{
7024	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7025	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7026	····}
7027	}
7028
7029
7030	[TestFixture]
7031	public class MappingTestAgrBi1nOthpabsNoTblAuto
7032	{
7033	····PersistenceManager pm;
7034	····NDOMapping mapping;
7035	····Class ownClass;
7036	····Class otherClass;
7037	····Class otherDerivedClass;
7038	····[SetUp]
7039	····public void Setup()
7040	····{
7041	········this.pm = PmFactory.NewPersistenceManager();
7042	········this.mapping = pm.NDOMapping;
7043	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsNoTblAutoLeft" );
7044	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsNoTblAutoRightBase" );
7045	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsNoTblAutoRightDerived" );
7046	····}
7047	····[Test]
7048	····public void HasMappingTable()
7049	····{
7050	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
7051	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
7052	Assert. Null( otherDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #8") ;
7053	····}
7054	····[Test]
7055	····public void HasTypeColumn()
7056	····{
7057	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #9") ;
7058	····}
7059	····[Test]
7060	····public void HasTypeCode()
7061	····{
7062	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7063	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7064	····}
7065	}
7066
7067
7068	[TestFixture]
7069	public class MappingTestAgrBi1nOthpabsTblAuto
7070	{
7071	····PersistenceManager pm;
7072	····NDOMapping mapping;
7073	····Class ownClass;
7074	····Class otherClass;
7075	····Class otherDerivedClass;
7076	····[SetUp]
7077	····public void Setup()
7078	····{
7079	········this.pm = PmFactory.NewPersistenceManager();
7080	········this.mapping = pm.NDOMapping;
7081	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsTblAutoLeft" );
7082	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsTblAutoRightBase" );
7083	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsTblAutoRightDerived" );
7084	····}
7085	····[Test]
7086	····public void HasMappingTable()
7087	····{
7088	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
7089	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
7090	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
7091	····}
7092	····[Test]
7093	····public void HasTypeColumn()
7094	····{
7095	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
7096	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
7097	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
7098	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
7099	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
7100	····}
7101	····[Test]
7102	····public void HasTypeCode()
7103	····{
7104	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7105	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7106	····}
7107	}
7108
7109
7110	[TestFixture]
7111	public class MappingTestAgrBinnOthpabsTblAuto
7112	{
7113	····PersistenceManager pm;
7114	····NDOMapping mapping;
7115	····Class ownClass;
7116	····Class otherClass;
7117	····Class otherDerivedClass;
7118	····[SetUp]
7119	····public void Setup()
7120	····{
7121	········this.pm = PmFactory.NewPersistenceManager();
7122	········this.mapping = pm.NDOMapping;
7123	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpabsTblAutoLeft" );
7124	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpabsTblAutoRightBase" );
7125	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpabsTblAutoRightDerived" );
7126	····}
7127	····[Test]
7128	····public void HasMappingTable()
7129	····{
7130	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
7131	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
7132	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
7133	····}
7134	····[Test]
7135	····public void HasTypeColumn()
7136	····{
7137	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
7138	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
7139	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
7140	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
7141	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
7142	····}
7143	····[Test]
7144	····public void HasTypeCode()
7145	····{
7146	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7147	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7148	····}
7149	}
7150
7151
7152	[TestFixture]
7153	public class MappingTestCmpDir1OthpabsTblAuto
7154	{
7155	····PersistenceManager pm;
7156	····NDOMapping mapping;
7157	····Class ownClass;
7158	····Class otherClass;
7159	····Class otherDerivedClass;
7160	····[SetUp]
7161	····public void Setup()
7162	····{
7163	········this.pm = PmFactory.NewPersistenceManager();
7164	········this.mapping = pm.NDOMapping;
7165	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsTblAutoLeft" );
7166	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsTblAutoRightBase" );
7167	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsTblAutoRightDerived" );
7168	····}
7169	····[Test]
7170	····public void HasMappingTable()
7171	····{
7172	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
7173	····}
7174	····[Test]
7175	····public void HasTypeColumn()
7176	····{
7177	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
7178	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
7179	····}
7180	····[Test]
7181	····public void HasTypeCode()
7182	····{
7183	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7184	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7185	····}
7186	}
7187
7188
7189	[TestFixture]
7190	public class MappingTestCmpBi11OthpabsTblAuto
7191	{
7192	····PersistenceManager pm;
7193	····NDOMapping mapping;
7194	····Class ownClass;
7195	····Class otherClass;
7196	····Class otherDerivedClass;
7197	····[SetUp]
7198	····public void Setup()
7199	····{
7200	········this.pm = PmFactory.NewPersistenceManager();
7201	········this.mapping = pm.NDOMapping;
7202	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsTblAutoLeft" );
7203	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsTblAutoRightBase" );
7204	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsTblAutoRightDerived" );
7205	····}
7206	····[Test]
7207	····public void HasMappingTable()
7208	····{
7209	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
7210	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
7211	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
7212	····}
7213	····[Test]
7214	····public void HasTypeColumn()
7215	····{
7216	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
7217	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
7218	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
7219	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
7220	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
7221	····}
7222	····[Test]
7223	····public void HasTypeCode()
7224	····{
7225	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7226	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7227	····}
7228	}
7229
7230
7231	[TestFixture]
7232	public class MappingTestCmpDirnOthpabsTblAuto
7233	{
7234	····PersistenceManager pm;
7235	····NDOMapping mapping;
7236	····Class ownClass;
7237	····Class otherClass;
7238	····Class otherDerivedClass;
7239	····[SetUp]
7240	····public void Setup()
7241	····{
7242	········this.pm = PmFactory.NewPersistenceManager();
7243	········this.mapping = pm.NDOMapping;
7244	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpabsTblAutoLeft" );
7245	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpabsTblAutoRightBase" );
7246	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpabsTblAutoRightDerived" );
7247	····}
7248	····[Test]
7249	····public void HasMappingTable()
7250	····{
7251	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
7252	····}
7253	····[Test]
7254	····public void HasTypeColumn()
7255	····{
7256	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
7257	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
7258	····}
7259	····[Test]
7260	····public void HasTypeCode()
7261	····{
7262	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7263	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7264	····}
7265	}
7266
7267
7268	[TestFixture]
7269	public class MappingTestCmpBin1OthpabsTblAuto
7270	{
7271	····PersistenceManager pm;
7272	····NDOMapping mapping;
7273	····Class ownClass;
7274	····Class otherClass;
7275	····Class otherDerivedClass;
7276	····[SetUp]
7277	····public void Setup()
7278	····{
7279	········this.pm = PmFactory.NewPersistenceManager();
7280	········this.mapping = pm.NDOMapping;
7281	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpabsTblAutoLeft" );
7282	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpabsTblAutoRightBase" );
7283	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpabsTblAutoRightDerived" );
7284	····}
7285	····[Test]
7286	····public void HasMappingTable()
7287	····{
7288	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
7289	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
7290	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
7291	····}
7292	····[Test]
7293	····public void HasTypeColumn()
7294	····{
7295	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
7296	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
7297	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
7298	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
7299	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
7300	····}
7301	····[Test]
7302	····public void HasTypeCode()
7303	····{
7304	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7305	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7306	····}
7307	}
7308
7309
7310	[TestFixture]
7311	public class MappingTestCmpBi1nOthpabsTblAuto
7312	{
7313	····PersistenceManager pm;
7314	····NDOMapping mapping;
7315	····Class ownClass;
7316	····Class otherClass;
7317	····Class otherDerivedClass;
7318	····[SetUp]
7319	····public void Setup()
7320	····{
7321	········this.pm = PmFactory.NewPersistenceManager();
7322	········this.mapping = pm.NDOMapping;
7323	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsTblAutoLeft" );
7324	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsTblAutoRightBase" );
7325	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsTblAutoRightDerived" );
7326	····}
7327	····[Test]
7328	····public void HasMappingTable()
7329	····{
7330	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
7331	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
7332	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
7333	····}
7334	····[Test]
7335	····public void HasTypeColumn()
7336	····{
7337	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
7338	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
7339	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
7340	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
7341	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
7342	····}
7343	····[Test]
7344	····public void HasTypeCode()
7345	····{
7346	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7347	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7348	····}
7349	}
7350
7351
7352	[TestFixture]
7353	public class MappingTestCmpBinnOthpabsTblAuto
7354	{
7355	····PersistenceManager pm;
7356	····NDOMapping mapping;
7357	····Class ownClass;
7358	····Class otherClass;
7359	····Class otherDerivedClass;
7360	····[SetUp]
7361	····public void Setup()
7362	····{
7363	········this.pm = PmFactory.NewPersistenceManager();
7364	········this.mapping = pm.NDOMapping;
7365	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpabsTblAutoLeft" );
7366	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpabsTblAutoRightBase" );
7367	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpabsTblAutoRightDerived" );
7368	····}
7369	····[Test]
7370	····public void HasMappingTable()
7371	····{
7372	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
7373	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
7374	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
7375	····}
7376	····[Test]
7377	····public void HasTypeColumn()
7378	····{
7379	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
7380	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
7381	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
7382	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
7383	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
7384	····}
7385	····[Test]
7386	····public void HasTypeCode()
7387	····{
7388	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7389	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7390	····}
7391	}
7392
7393
7394	[TestFixture]
7395	public class MappingTestAgrDir1OwnpabsOthpabsNoTblAuto
7396	{
7397	····PersistenceManager pm;
7398	····NDOMapping mapping;
7399	····Class ownClass;
7400	····Class otherClass;
7401	····Class ownDerivedClass;
7402	····Class otherDerivedClass;
7403	····[SetUp]
7404	····public void Setup()
7405	····{
7406	········this.pm = PmFactory.NewPersistenceManager();
7407	········this.mapping = pm.NDOMapping;
7408	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsNoTblAutoLeftBase" );
7409	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsNoTblAutoRightBase" );
7410	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsNoTblAutoLeftDerived" );
7411	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsNoTblAutoRightDerived" );
7412	····}
7413	····[Test]
7414	····public void HasMappingTable()
7415	····{
7416	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
7417	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
7418	····}
7419	····[Test]
7420	····public void HasTypeColumn()
7421	····{
7422	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #9") ;
7423	····}
7424	····[Test]
7425	····public void HasTypeCode()
7426	····{
7427	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7428	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7429	····}
7430	}
7431
7432
7433	[TestFixture]
7434	public class MappingTestAgrDir1OwnpabsOthpabsTblAuto
7435	{
7436	····PersistenceManager pm;
7437	····NDOMapping mapping;
7438	····Class ownClass;
7439	····Class otherClass;
7440	····Class ownDerivedClass;
7441	····Class otherDerivedClass;
7442	····[SetUp]
7443	····public void Setup()
7444	····{
7445	········this.pm = PmFactory.NewPersistenceManager();
7446	········this.mapping = pm.NDOMapping;
7447	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsTblAutoLeftBase" );
7448	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsTblAutoRightBase" );
7449	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsTblAutoLeftDerived" );
7450	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsTblAutoRightDerived" );
7451	····}
7452	····[Test]
7453	····public void HasMappingTable()
7454	····{
7455	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
7456	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
7457	····}
7458	····[Test]
7459	····public void HasTypeColumn()
7460	····{
7461	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
7462	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
7463	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
7464	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
7465	····}
7466	····[Test]
7467	····public void HasTypeCode()
7468	····{
7469	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7470	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7471	····}
7472	}
7473
7474
7475	[TestFixture]
7476	public class MappingTestAgrBi11OwnpabsOthpabsNoTblAuto
7477	{
7478	····PersistenceManager pm;
7479	····NDOMapping mapping;
7480	····Class ownClass;
7481	····Class otherClass;
7482	····Class ownDerivedClass;
7483	····Class otherDerivedClass;
7484	····[SetUp]
7485	····public void Setup()
7486	····{
7487	········this.pm = PmFactory.NewPersistenceManager();
7488	········this.mapping = pm.NDOMapping;
7489	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsNoTblAutoLeftBase" );
7490	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsNoTblAutoRightBase" );
7491	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsNoTblAutoLeftDerived" );
7492	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsNoTblAutoRightDerived" );
7493	····}
7494	····[Test]
7495	····public void HasMappingTable()
7496	····{
7497	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
7498	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
7499	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
7500	Assert. Null( otherDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #8") ;
7501	····}
7502	····[Test]
7503	····public void HasTypeColumn()
7504	····{
7505	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #9") ;
7506	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #10") ;
7507	····}
7508	····[Test]
7509	····public void HasTypeCode()
7510	····{
7511	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7512	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7513	····}
7514	}
7515
7516
7517	[TestFixture]
7518	public class MappingTestAgrBi11OwnpabsOthpabsTblAuto
7519	{
7520	····PersistenceManager pm;
7521	····NDOMapping mapping;
7522	····Class ownClass;
7523	····Class otherClass;
7524	····Class ownDerivedClass;
7525	····Class otherDerivedClass;
7526	····[SetUp]
7527	····public void Setup()
7528	····{
7529	········this.pm = PmFactory.NewPersistenceManager();
7530	········this.mapping = pm.NDOMapping;
7531	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsTblAutoLeftBase" );
7532	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsTblAutoRightBase" );
7533	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsTblAutoLeftDerived" );
7534	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsTblAutoRightDerived" );
7535	····}
7536	····[Test]
7537	····public void HasMappingTable()
7538	····{
7539	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
7540	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
7541	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
7542	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
7543	····}
7544	····[Test]
7545	····public void HasTypeColumn()
7546	····{
7547	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
7548	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
7549	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
7550	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
7551	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
7552	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
7553	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
7554	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #8") ;
7555	····}
7556	····[Test]
7557	····public void HasTypeCode()
7558	····{
7559	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7560	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7561	····}
7562	}
7563
7564
7565	[TestFixture]
7566	public class MappingTestAgrDirnOwnpabsOthpabsTblAuto
7567	{
7568	····PersistenceManager pm;
7569	····NDOMapping mapping;
7570	····Class ownClass;
7571	····Class otherClass;
7572	····Class ownDerivedClass;
7573	····Class otherDerivedClass;
7574	····[SetUp]
7575	····public void Setup()
7576	····{
7577	········this.pm = PmFactory.NewPersistenceManager();
7578	········this.mapping = pm.NDOMapping;
7579	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsOthpabsTblAutoLeftBase" );
7580	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsOthpabsTblAutoRightBase" );
7581	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsOthpabsTblAutoLeftDerived" );
7582	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsOthpabsTblAutoRightDerived" );
7583	····}
7584	····[Test]
7585	····public void HasMappingTable()
7586	····{
7587	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
7588	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
7589	····}
7590	····[Test]
7591	····public void HasTypeColumn()
7592	····{
7593	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
7594	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
7595	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
7596	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
7597	····}
7598	····[Test]
7599	····public void HasTypeCode()
7600	····{
7601	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7602	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7603	····}
7604	}
7605
7606
7607	[TestFixture]
7608	public class MappingTestAgrBin1OwnpabsOthpabsTblAuto
7609	{
7610	····PersistenceManager pm;
7611	····NDOMapping mapping;
7612	····Class ownClass;
7613	····Class otherClass;
7614	····Class ownDerivedClass;
7615	····Class otherDerivedClass;
7616	····[SetUp]
7617	····public void Setup()
7618	····{
7619	········this.pm = PmFactory.NewPersistenceManager();
7620	········this.mapping = pm.NDOMapping;
7621	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsOthpabsTblAutoLeftBase" );
7622	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsOthpabsTblAutoRightBase" );
7623	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsOthpabsTblAutoLeftDerived" );
7624	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsOthpabsTblAutoRightDerived" );
7625	····}
7626	····[Test]
7627	····public void HasMappingTable()
7628	····{
7629	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
7630	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
7631	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
7632	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
7633	····}
7634	····[Test]
7635	····public void HasTypeColumn()
7636	····{
7637	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
7638	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
7639	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
7640	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
7641	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
7642	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
7643	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
7644	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #8") ;
7645	····}
7646	····[Test]
7647	····public void HasTypeCode()
7648	····{
7649	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7650	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7651	····}
7652	}
7653
7654
7655	[TestFixture]
7656	public class MappingTestAgrBi1nOwnpabsOthpabsTblAuto
7657	{
7658	····PersistenceManager pm;
7659	····NDOMapping mapping;
7660	····Class ownClass;
7661	····Class otherClass;
7662	····Class ownDerivedClass;
7663	····Class otherDerivedClass;
7664	····[SetUp]
7665	····public void Setup()
7666	····{
7667	········this.pm = PmFactory.NewPersistenceManager();
7668	········this.mapping = pm.NDOMapping;
7669	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsOthpabsTblAutoLeftBase" );
7670	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsOthpabsTblAutoRightBase" );
7671	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsOthpabsTblAutoLeftDerived" );
7672	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsOthpabsTblAutoRightDerived" );
7673	····}
7674	····[Test]
7675	····public void HasMappingTable()
7676	····{
7677	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
7678	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
7679	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
7680	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
7681	····}
7682	····[Test]
7683	····public void HasTypeColumn()
7684	····{
7685	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
7686	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
7687	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
7688	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
7689	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
7690	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
7691	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
7692	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #8") ;
7693	····}
7694	····[Test]
7695	····public void HasTypeCode()
7696	····{
7697	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7698	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7699	····}
7700	}
7701
7702
7703	[TestFixture]
7704	public class MappingTestAgrBinnOwnpabsOthpabsTblAuto
7705	{
7706	····PersistenceManager pm;
7707	····NDOMapping mapping;
7708	····Class ownClass;
7709	····Class otherClass;
7710	····Class ownDerivedClass;
7711	····Class otherDerivedClass;
7712	····[SetUp]
7713	····public void Setup()
7714	····{
7715	········this.pm = PmFactory.NewPersistenceManager();
7716	········this.mapping = pm.NDOMapping;
7717	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsOthpabsTblAutoLeftBase" );
7718	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsOthpabsTblAutoRightBase" );
7719	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsOthpabsTblAutoLeftDerived" );
7720	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsOthpabsTblAutoRightDerived" );
7721	····}
7722	····[Test]
7723	····public void HasMappingTable()
7724	····{
7725	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
7726	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
7727	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
7728	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
7729	····}
7730	····[Test]
7731	····public void HasTypeColumn()
7732	····{
7733	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
7734	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
7735	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
7736	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
7737	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
7738	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
7739	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
7740	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #8") ;
7741	····}
7742	····[Test]
7743	····public void HasTypeCode()
7744	····{
7745	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7746	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7747	····}
7748	}
7749
7750
7751	[TestFixture]
7752	public class MappingTestCmpDir1OwnpabsOthpabsTblAuto
7753	{
7754	····PersistenceManager pm;
7755	····NDOMapping mapping;
7756	····Class ownClass;
7757	····Class otherClass;
7758	····Class ownDerivedClass;
7759	····Class otherDerivedClass;
7760	····[SetUp]
7761	····public void Setup()
7762	····{
7763	········this.pm = PmFactory.NewPersistenceManager();
7764	········this.mapping = pm.NDOMapping;
7765	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsTblAutoLeftBase" );
7766	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsTblAutoRightBase" );
7767	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsTblAutoLeftDerived" );
7768	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsTblAutoRightDerived" );
7769	····}
7770	····[Test]
7771	····public void HasMappingTable()
7772	····{
7773	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
7774	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
7775	····}
7776	····[Test]
7777	····public void HasTypeColumn()
7778	····{
7779	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
7780	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
7781	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
7782	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
7783	····}
7784	····[Test]
7785	····public void HasTypeCode()
7786	····{
7787	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7788	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7789	····}
7790	}
7791
7792
7793	[TestFixture]
7794	public class MappingTestCmpBi11OwnpabsOthpabsTblAuto
7795	{
7796	····PersistenceManager pm;
7797	····NDOMapping mapping;
7798	····Class ownClass;
7799	····Class otherClass;
7800	····Class ownDerivedClass;
7801	····Class otherDerivedClass;
7802	····[SetUp]
7803	····public void Setup()
7804	····{
7805	········this.pm = PmFactory.NewPersistenceManager();
7806	········this.mapping = pm.NDOMapping;
7807	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsTblAutoLeftBase" );
7808	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsTblAutoRightBase" );
7809	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsTblAutoLeftDerived" );
7810	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsTblAutoRightDerived" );
7811	····}
7812	····[Test]
7813	····public void HasMappingTable()
7814	····{
7815	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
7816	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
7817	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
7818	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
7819	····}
7820	····[Test]
7821	····public void HasTypeColumn()
7822	····{
7823	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
7824	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
7825	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
7826	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
7827	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
7828	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
7829	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
7830	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #8") ;
7831	····}
7832	····[Test]
7833	····public void HasTypeCode()
7834	····{
7835	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7836	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7837	····}
7838	}
7839
7840
7841	[TestFixture]
7842	public class MappingTestCmpDirnOwnpabsOthpabsTblAuto
7843	{
7844	····PersistenceManager pm;
7845	····NDOMapping mapping;
7846	····Class ownClass;
7847	····Class otherClass;
7848	····Class ownDerivedClass;
7849	····Class otherDerivedClass;
7850	····[SetUp]
7851	····public void Setup()
7852	····{
7853	········this.pm = PmFactory.NewPersistenceManager();
7854	········this.mapping = pm.NDOMapping;
7855	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsOthpabsTblAutoLeftBase" );
7856	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsOthpabsTblAutoRightBase" );
7857	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsOthpabsTblAutoLeftDerived" );
7858	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsOthpabsTblAutoRightDerived" );
7859	····}
7860	····[Test]
7861	····public void HasMappingTable()
7862	····{
7863	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
7864	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
7865	····}
7866	····[Test]
7867	····public void HasTypeColumn()
7868	····{
7869	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
7870	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
7871	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
7872	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
7873	····}
7874	····[Test]
7875	····public void HasTypeCode()
7876	····{
7877	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7878	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7879	····}
7880	}
7881
7882
7883	[TestFixture]
7884	public class MappingTestCmpBin1OwnpabsOthpabsTblAuto
7885	{
7886	····PersistenceManager pm;
7887	····NDOMapping mapping;
7888	····Class ownClass;
7889	····Class otherClass;
7890	····Class ownDerivedClass;
7891	····Class otherDerivedClass;
7892	····[SetUp]
7893	····public void Setup()
7894	····{
7895	········this.pm = PmFactory.NewPersistenceManager();
7896	········this.mapping = pm.NDOMapping;
7897	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsOthpabsTblAutoLeftBase" );
7898	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsOthpabsTblAutoRightBase" );
7899	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsOthpabsTblAutoLeftDerived" );
7900	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsOthpabsTblAutoRightDerived" );
7901	····}
7902	····[Test]
7903	····public void HasMappingTable()
7904	····{
7905	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
7906	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
7907	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
7908	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
7909	····}
7910	····[Test]
7911	····public void HasTypeColumn()
7912	····{
7913	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
7914	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
7915	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
7916	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
7917	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
7918	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
7919	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
7920	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #8") ;
7921	····}
7922	····[Test]
7923	····public void HasTypeCode()
7924	····{
7925	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7926	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7927	····}
7928	}
7929
7930
7931	[TestFixture]
7932	public class MappingTestCmpBi1nOwnpabsOthpabsTblAuto
7933	{
7934	····PersistenceManager pm;
7935	····NDOMapping mapping;
7936	····Class ownClass;
7937	····Class otherClass;
7938	····Class ownDerivedClass;
7939	····Class otherDerivedClass;
7940	····[SetUp]
7941	····public void Setup()
7942	····{
7943	········this.pm = PmFactory.NewPersistenceManager();
7944	········this.mapping = pm.NDOMapping;
7945	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsOthpabsTblAutoLeftBase" );
7946	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsOthpabsTblAutoRightBase" );
7947	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsOthpabsTblAutoLeftDerived" );
7948	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsOthpabsTblAutoRightDerived" );
7949	····}
7950	····[Test]
7951	····public void HasMappingTable()
7952	····{
7953	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
7954	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
7955	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
7956	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
7957	····}
7958	····[Test]
7959	····public void HasTypeColumn()
7960	····{
7961	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
7962	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
7963	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
7964	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
7965	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
7966	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
7967	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
7968	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #8") ;
7969	····}
7970	····[Test]
7971	····public void HasTypeCode()
7972	····{
7973	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7974	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7975	····}
7976	}
7977
7978
7979	[TestFixture]
7980	public class MappingTestCmpBinnOwnpabsOthpabsTblAuto
7981	{
7982	····PersistenceManager pm;
7983	····NDOMapping mapping;
7984	····Class ownClass;
7985	····Class otherClass;
7986	····Class ownDerivedClass;
7987	····Class otherDerivedClass;
7988	····[SetUp]
7989	····public void Setup()
7990	····{
7991	········this.pm = PmFactory.NewPersistenceManager();
7992	········this.mapping = pm.NDOMapping;
7993	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsOthpabsTblAutoLeftBase" );
7994	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsOthpabsTblAutoRightBase" );
7995	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsOthpabsTblAutoLeftDerived" );
7996	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsOthpabsTblAutoRightDerived" );
7997	····}
7998	····[Test]
7999	····public void HasMappingTable()
8000	····{
8001	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
8002	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
8003	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
8004	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
8005	····}
8006	····[Test]
8007	····public void HasTypeColumn()
8008	····{
8009	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
8010	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
8011	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
8012	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
8013	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
8014	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
8015	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
8016	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #8") ;
8017	····}
8018	····[Test]
8019	····public void HasTypeCode()
8020	····{
8021	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8022	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
8023	····}
8024	}
8025
8026
8027	[TestFixture]
8028	public class MappingTestAgrDir1OwnpabsNoTblGuid
8029	{
8030	····PersistenceManager pm;
8031	····NDOMapping mapping;
8032	····Class ownClass;
8033	····Class otherClass;
8034	····Class ownDerivedClass;
8035	····[SetUp]
8036	····public void Setup()
8037	····{
8038	········this.pm = PmFactory.NewPersistenceManager();
8039	········this.mapping = pm.NDOMapping;
8040	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsNoTblGuidLeftBase" );
8041	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsNoTblGuidRight" );
8042	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsNoTblGuidLeftDerived" );
8043	····}
8044	····[Test]
8045	····public void HasMappingTable()
8046	····{
8047	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
8048	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
8049	····}
8050	····[Test]
8051	····public void HasTypeColumn()
8052	····{
8053	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
8054	····}
8055	····[Test]
8056	····public void HasTypeCode()
8057	····{
8058	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8059	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8060	····}
8061	}
8062
8063
8064	[TestFixture]
8065	public class MappingTestAgrDir1OwnpabsTblGuid
8066	{
8067	····PersistenceManager pm;
8068	····NDOMapping mapping;
8069	····Class ownClass;
8070	····Class otherClass;
8071	····Class ownDerivedClass;
8072	····[SetUp]
8073	····public void Setup()
8074	····{
8075	········this.pm = PmFactory.NewPersistenceManager();
8076	········this.mapping = pm.NDOMapping;
8077	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsTblGuidLeftBase" );
8078	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsTblGuidRight" );
8079	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsTblGuidLeftDerived" );
8080	····}
8081	····[Test]
8082	····public void HasMappingTable()
8083	····{
8084	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
8085	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
8086	····}
8087	····[Test]
8088	····public void HasTypeColumn()
8089	····{
8090	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
8091	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
8092	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
8093	····}
8094	····[Test]
8095	····public void HasTypeCode()
8096	····{
8097	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8098	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8099	····}
8100	}
8101
8102
8103	[TestFixture]
8104	public class MappingTestAgrBi11OwnpabsNoTblGuid
8105	{
8106	····PersistenceManager pm;
8107	····NDOMapping mapping;
8108	····Class ownClass;
8109	····Class otherClass;
8110	····Class ownDerivedClass;
8111	····[SetUp]
8112	····public void Setup()
8113	····{
8114	········this.pm = PmFactory.NewPersistenceManager();
8115	········this.mapping = pm.NDOMapping;
8116	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsNoTblGuidLeftBase" );
8117	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsNoTblGuidRight" );
8118	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsNoTblGuidLeftDerived" );
8119	····}
8120	····[Test]
8121	····public void HasMappingTable()
8122	····{
8123	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
8124	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
8125	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
8126	····}
8127	····[Test]
8128	····public void HasTypeColumn()
8129	····{
8130	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
8131	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #10") ;
8132	····}
8133	····[Test]
8134	····public void HasTypeCode()
8135	····{
8136	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8137	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8138	····}
8139	}
8140
8141
8142	[TestFixture]
8143	public class MappingTestAgrBi11OwnpabsTblGuid
8144	{
8145	····PersistenceManager pm;
8146	····NDOMapping mapping;
8147	····Class ownClass;
8148	····Class otherClass;
8149	····Class ownDerivedClass;
8150	····[SetUp]
8151	····public void Setup()
8152	····{
8153	········this.pm = PmFactory.NewPersistenceManager();
8154	········this.mapping = pm.NDOMapping;
8155	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsTblGuidLeftBase" );
8156	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsTblGuidRight" );
8157	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsTblGuidLeftDerived" );
8158	····}
8159	····[Test]
8160	····public void HasMappingTable()
8161	····{
8162	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
8163	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
8164	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
8165	····}
8166	····[Test]
8167	····public void HasTypeColumn()
8168	····{
8169	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
8170	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
8171	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
8172	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
8173	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
8174	····}
8175	····[Test]
8176	····public void HasTypeCode()
8177	····{
8178	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8179	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8180	····}
8181	}
8182
8183
8184	[TestFixture]
8185	public class MappingTestAgrDirnOwnpabsNoTblGuid
8186	{
8187	····PersistenceManager pm;
8188	····NDOMapping mapping;
8189	····Class ownClass;
8190	····Class otherClass;
8191	····Class ownDerivedClass;
8192	····[SetUp]
8193	····public void Setup()
8194	····{
8195	········this.pm = PmFactory.NewPersistenceManager();
8196	········this.mapping = pm.NDOMapping;
8197	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsNoTblGuidLeftBase" );
8198	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsNoTblGuidRight" );
8199	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsNoTblGuidLeftDerived" );
8200	····}
8201	····[Test]
8202	····public void HasMappingTable()
8203	····{
8204	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
8205	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
8206	····}
8207	····[Test]
8208	····public void HasTypeColumn()
8209	····{
8210	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
8211	····}
8212	····[Test]
8213	····public void HasTypeCode()
8214	····{
8215	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8216	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8217	····}
8218	}
8219
8220
8221	[TestFixture]
8222	public class MappingTestAgrDirnOwnpabsTblGuid
8223	{
8224	····PersistenceManager pm;
8225	····NDOMapping mapping;
8226	····Class ownClass;
8227	····Class otherClass;
8228	····Class ownDerivedClass;
8229	····[SetUp]
8230	····public void Setup()
8231	····{
8232	········this.pm = PmFactory.NewPersistenceManager();
8233	········this.mapping = pm.NDOMapping;
8234	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsTblGuidLeftBase" );
8235	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsTblGuidRight" );
8236	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsTblGuidLeftDerived" );
8237	····}
8238	····[Test]
8239	····public void HasMappingTable()
8240	····{
8241	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
8242	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
8243	····}
8244	····[Test]
8245	····public void HasTypeColumn()
8246	····{
8247	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
8248	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
8249	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
8250	····}
8251	····[Test]
8252	····public void HasTypeCode()
8253	····{
8254	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8255	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8256	····}
8257	}
8258
8259
8260	[TestFixture]
8261	public class MappingTestAgrBin1OwnpabsNoTblGuid
8262	{
8263	····PersistenceManager pm;
8264	····NDOMapping mapping;
8265	····Class ownClass;
8266	····Class otherClass;
8267	····Class ownDerivedClass;
8268	····[SetUp]
8269	····public void Setup()
8270	····{
8271	········this.pm = PmFactory.NewPersistenceManager();
8272	········this.mapping = pm.NDOMapping;
8273	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsNoTblGuidLeftBase" );
8274	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsNoTblGuidRight" );
8275	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsNoTblGuidLeftDerived" );
8276	····}
8277	····[Test]
8278	····public void HasMappingTable()
8279	····{
8280	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
8281	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
8282	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
8283	····}
8284	····[Test]
8285	····public void HasTypeColumn()
8286	····{
8287	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
8288	····}
8289	····[Test]
8290	····public void HasTypeCode()
8291	····{
8292	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8293	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8294	····}
8295	}
8296
8297
8298	[TestFixture]
8299	public class MappingTestAgrBin1OwnpabsTblGuid
8300	{
8301	····PersistenceManager pm;
8302	····NDOMapping mapping;
8303	····Class ownClass;
8304	····Class otherClass;
8305	····Class ownDerivedClass;
8306	····[SetUp]
8307	····public void Setup()
8308	····{
8309	········this.pm = PmFactory.NewPersistenceManager();
8310	········this.mapping = pm.NDOMapping;
8311	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsTblGuidLeftBase" );
8312	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsTblGuidRight" );
8313	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsTblGuidLeftDerived" );
8314	····}
8315	····[Test]
8316	····public void HasMappingTable()
8317	····{
8318	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
8319	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
8320	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
8321	····}
8322	····[Test]
8323	····public void HasTypeColumn()
8324	····{
8325	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
8326	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
8327	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
8328	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
8329	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
8330	····}
8331	····[Test]
8332	····public void HasTypeCode()
8333	····{
8334	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8335	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8336	····}
8337	}
8338
8339
8340	[TestFixture]
8341	public class MappingTestAgrBi1nOwnpabsTblGuid
8342	{
8343	····PersistenceManager pm;
8344	····NDOMapping mapping;
8345	····Class ownClass;
8346	····Class otherClass;
8347	····Class ownDerivedClass;
8348	····[SetUp]
8349	····public void Setup()
8350	····{
8351	········this.pm = PmFactory.NewPersistenceManager();
8352	········this.mapping = pm.NDOMapping;
8353	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsTblGuidLeftBase" );
8354	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsTblGuidRight" );
8355	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsTblGuidLeftDerived" );
8356	····}
8357	····[Test]
8358	····public void HasMappingTable()
8359	····{
8360	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
8361	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
8362	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
8363	····}
8364	····[Test]
8365	····public void HasTypeColumn()
8366	····{
8367	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
8368	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
8369	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
8370	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
8371	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
8372	····}
8373	····[Test]
8374	····public void HasTypeCode()
8375	····{
8376	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8377	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8378	····}
8379	}
8380
8381
8382	[TestFixture]
8383	public class MappingTestAgrBinnOwnpabsTblGuid
8384	{
8385	····PersistenceManager pm;
8386	····NDOMapping mapping;
8387	····Class ownClass;
8388	····Class otherClass;
8389	····Class ownDerivedClass;
8390	····[SetUp]
8391	····public void Setup()
8392	····{
8393	········this.pm = PmFactory.NewPersistenceManager();
8394	········this.mapping = pm.NDOMapping;
8395	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsTblGuidLeftBase" );
8396	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsTblGuidRight" );
8397	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsTblGuidLeftDerived" );
8398	····}
8399	····[Test]
8400	····public void HasMappingTable()
8401	····{
8402	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
8403	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
8404	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
8405	····}
8406	····[Test]
8407	····public void HasTypeColumn()
8408	····{
8409	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
8410	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
8411	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
8412	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
8413	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
8414	····}
8415	····[Test]
8416	····public void HasTypeCode()
8417	····{
8418	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8419	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8420	····}
8421	}
8422
8423
8424	[TestFixture]
8425	public class MappingTestCmpDir1OwnpabsNoTblGuid
8426	{
8427	····PersistenceManager pm;
8428	····NDOMapping mapping;
8429	····Class ownClass;
8430	····Class otherClass;
8431	····Class ownDerivedClass;
8432	····[SetUp]
8433	····public void Setup()
8434	····{
8435	········this.pm = PmFactory.NewPersistenceManager();
8436	········this.mapping = pm.NDOMapping;
8437	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsNoTblGuidLeftBase" );
8438	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsNoTblGuidRight" );
8439	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsNoTblGuidLeftDerived" );
8440	····}
8441	····[Test]
8442	····public void HasMappingTable()
8443	····{
8444	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
8445	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
8446	····}
8447	····[Test]
8448	····public void HasTypeColumn()
8449	····{
8450	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
8451	····}
8452	····[Test]
8453	····public void HasTypeCode()
8454	····{
8455	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8456	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8457	····}
8458	}
8459
8460
8461	[TestFixture]
8462	public class MappingTestCmpDir1OwnpabsTblGuid
8463	{
8464	····PersistenceManager pm;
8465	····NDOMapping mapping;
8466	····Class ownClass;
8467	····Class otherClass;
8468	····Class ownDerivedClass;
8469	····[SetUp]
8470	····public void Setup()
8471	····{
8472	········this.pm = PmFactory.NewPersistenceManager();
8473	········this.mapping = pm.NDOMapping;
8474	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsTblGuidLeftBase" );
8475	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsTblGuidRight" );
8476	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsTblGuidLeftDerived" );
8477	····}
8478	····[Test]
8479	····public void HasMappingTable()
8480	····{
8481	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
8482	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
8483	····}
8484	····[Test]
8485	····public void HasTypeColumn()
8486	····{
8487	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
8488	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
8489	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
8490	····}
8491	····[Test]
8492	····public void HasTypeCode()
8493	····{
8494	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8495	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8496	····}
8497	}
8498
8499
8500	[TestFixture]
8501	public class MappingTestCmpBi11OwnpabsNoTblGuid
8502	{
8503	····PersistenceManager pm;
8504	····NDOMapping mapping;
8505	····Class ownClass;
8506	····Class otherClass;
8507	····Class ownDerivedClass;
8508	····[SetUp]
8509	····public void Setup()
8510	····{
8511	········this.pm = PmFactory.NewPersistenceManager();
8512	········this.mapping = pm.NDOMapping;
8513	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsNoTblGuidLeftBase" );
8514	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsNoTblGuidRight" );
8515	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsNoTblGuidLeftDerived" );
8516	····}
8517	····[Test]
8518	····public void HasMappingTable()
8519	····{
8520	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
8521	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
8522	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
8523	····}
8524	····[Test]
8525	····public void HasTypeColumn()
8526	····{
8527	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
8528	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #10") ;
8529	····}
8530	····[Test]
8531	····public void HasTypeCode()
8532	····{
8533	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8534	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8535	····}
8536	}
8537
8538
8539	[TestFixture]
8540	public class MappingTestCmpBi11OwnpabsTblGuid
8541	{
8542	····PersistenceManager pm;
8543	····NDOMapping mapping;
8544	····Class ownClass;
8545	····Class otherClass;
8546	····Class ownDerivedClass;
8547	····[SetUp]
8548	····public void Setup()
8549	····{
8550	········this.pm = PmFactory.NewPersistenceManager();
8551	········this.mapping = pm.NDOMapping;
8552	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsTblGuidLeftBase" );
8553	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsTblGuidRight" );
8554	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsTblGuidLeftDerived" );
8555	····}
8556	····[Test]
8557	····public void HasMappingTable()
8558	····{
8559	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
8560	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
8561	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
8562	····}
8563	····[Test]
8564	····public void HasTypeColumn()
8565	····{
8566	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
8567	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
8568	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
8569	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
8570	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
8571	····}
8572	····[Test]
8573	····public void HasTypeCode()
8574	····{
8575	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8576	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8577	····}
8578	}
8579
8580
8581	[TestFixture]
8582	public class MappingTestCmpDirnOwnpabsNoTblGuid
8583	{
8584	····PersistenceManager pm;
8585	····NDOMapping mapping;
8586	····Class ownClass;
8587	····Class otherClass;
8588	····Class ownDerivedClass;
8589	····[SetUp]
8590	····public void Setup()
8591	····{
8592	········this.pm = PmFactory.NewPersistenceManager();
8593	········this.mapping = pm.NDOMapping;
8594	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsNoTblGuidLeftBase" );
8595	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsNoTblGuidRight" );
8596	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsNoTblGuidLeftDerived" );
8597	····}
8598	····[Test]
8599	····public void HasMappingTable()
8600	····{
8601	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
8602	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
8603	····}
8604	····[Test]
8605	····public void HasTypeColumn()
8606	····{
8607	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
8608	····}
8609	····[Test]
8610	····public void HasTypeCode()
8611	····{
8612	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8613	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8614	····}
8615	}
8616
8617
8618	[TestFixture]
8619	public class MappingTestCmpDirnOwnpabsTblGuid
8620	{
8621	····PersistenceManager pm;
8622	····NDOMapping mapping;
8623	····Class ownClass;
8624	····Class otherClass;
8625	····Class ownDerivedClass;
8626	····[SetUp]
8627	····public void Setup()
8628	····{
8629	········this.pm = PmFactory.NewPersistenceManager();
8630	········this.mapping = pm.NDOMapping;
8631	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsTblGuidLeftBase" );
8632	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsTblGuidRight" );
8633	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsTblGuidLeftDerived" );
8634	····}
8635	····[Test]
8636	····public void HasMappingTable()
8637	····{
8638	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
8639	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
8640	····}
8641	····[Test]
8642	····public void HasTypeColumn()
8643	····{
8644	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
8645	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
8646	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
8647	····}
8648	····[Test]
8649	····public void HasTypeCode()
8650	····{
8651	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8652	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8653	····}
8654	}
8655
8656
8657	[TestFixture]
8658	public class MappingTestCmpBin1OwnpabsNoTblGuid
8659	{
8660	····PersistenceManager pm;
8661	····NDOMapping mapping;
8662	····Class ownClass;
8663	····Class otherClass;
8664	····Class ownDerivedClass;
8665	····[SetUp]
8666	····public void Setup()
8667	····{
8668	········this.pm = PmFactory.NewPersistenceManager();
8669	········this.mapping = pm.NDOMapping;
8670	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsNoTblGuidLeftBase" );
8671	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsNoTblGuidRight" );
8672	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsNoTblGuidLeftDerived" );
8673	····}
8674	····[Test]
8675	····public void HasMappingTable()
8676	····{
8677	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
8678	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
8679	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
8680	····}
8681	····[Test]
8682	····public void HasTypeColumn()
8683	····{
8684	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
8685	····}
8686	····[Test]
8687	····public void HasTypeCode()
8688	····{
8689	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8690	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8691	····}
8692	}
8693
8694
8695	[TestFixture]
8696	public class MappingTestCmpBin1OwnpabsTblGuid
8697	{
8698	····PersistenceManager pm;
8699	····NDOMapping mapping;
8700	····Class ownClass;
8701	····Class otherClass;
8702	····Class ownDerivedClass;
8703	····[SetUp]
8704	····public void Setup()
8705	····{
8706	········this.pm = PmFactory.NewPersistenceManager();
8707	········this.mapping = pm.NDOMapping;
8708	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsTblGuidLeftBase" );
8709	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsTblGuidRight" );
8710	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsTblGuidLeftDerived" );
8711	····}
8712	····[Test]
8713	····public void HasMappingTable()
8714	····{
8715	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
8716	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
8717	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
8718	····}
8719	····[Test]
8720	····public void HasTypeColumn()
8721	····{
8722	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
8723	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
8724	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
8725	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
8726	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
8727	····}
8728	····[Test]
8729	····public void HasTypeCode()
8730	····{
8731	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8732	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8733	····}
8734	}
8735
8736
8737	[TestFixture]
8738	public class MappingTestCmpBi1nOwnpabsTblGuid
8739	{
8740	····PersistenceManager pm;
8741	····NDOMapping mapping;
8742	····Class ownClass;
8743	····Class otherClass;
8744	····Class ownDerivedClass;
8745	····[SetUp]
8746	····public void Setup()
8747	····{
8748	········this.pm = PmFactory.NewPersistenceManager();
8749	········this.mapping = pm.NDOMapping;
8750	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsTblGuidLeftBase" );
8751	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsTblGuidRight" );
8752	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsTblGuidLeftDerived" );
8753	····}
8754	····[Test]
8755	····public void HasMappingTable()
8756	····{
8757	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
8758	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
8759	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
8760	····}
8761	····[Test]
8762	····public void HasTypeColumn()
8763	····{
8764	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
8765	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
8766	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
8767	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
8768	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
8769	····}
8770	····[Test]
8771	····public void HasTypeCode()
8772	····{
8773	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8774	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8775	····}
8776	}
8777
8778
8779	[TestFixture]
8780	public class MappingTestCmpBinnOwnpabsTblGuid
8781	{
8782	····PersistenceManager pm;
8783	····NDOMapping mapping;
8784	····Class ownClass;
8785	····Class otherClass;
8786	····Class ownDerivedClass;
8787	····[SetUp]
8788	····public void Setup()
8789	····{
8790	········this.pm = PmFactory.NewPersistenceManager();
8791	········this.mapping = pm.NDOMapping;
8792	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsTblGuidLeftBase" );
8793	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsTblGuidRight" );
8794	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsTblGuidLeftDerived" );
8795	····}
8796	····[Test]
8797	····public void HasMappingTable()
8798	····{
8799	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
8800	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
8801	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
8802	····}
8803	····[Test]
8804	····public void HasTypeColumn()
8805	····{
8806	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
8807	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
8808	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
8809	Assert. Null( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #3") ;
8810	Assert. Null( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #4") ;
8811	····}
8812	····[Test]
8813	····public void HasTypeCode()
8814	····{
8815	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8816	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8817	····}
8818	}
8819
8820
8821	[TestFixture]
8822	public class MappingTestAgrDir1OthpabsNoTblGuid
8823	{
8824	····PersistenceManager pm;
8825	····NDOMapping mapping;
8826	····Class ownClass;
8827	····Class otherClass;
8828	····Class otherDerivedClass;
8829	····[SetUp]
8830	····public void Setup()
8831	····{
8832	········this.pm = PmFactory.NewPersistenceManager();
8833	········this.mapping = pm.NDOMapping;
8834	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsNoTblGuidLeft" );
8835	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsNoTblGuidRightBase" );
8836	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsNoTblGuidRightDerived" );
8837	····}
8838	····[Test]
8839	····public void HasMappingTable()
8840	····{
8841	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
8842	····}
8843	····[Test]
8844	····public void HasTypeColumn()
8845	····{
8846	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #9") ;
8847	····}
8848	····[Test]
8849	····public void HasTypeCode()
8850	····{
8851	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
8852	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
8853	····}
8854	}
8855
8856
8857	[TestFixture]
8858	public class MappingTestAgrDir1OthpabsTblGuid
8859	{
8860	····PersistenceManager pm;
8861	····NDOMapping mapping;
8862	····Class ownClass;
8863	····Class otherClass;
8864	····Class otherDerivedClass;
8865	····[SetUp]
8866	····public void Setup()
8867	····{
8868	········this.pm = PmFactory.NewPersistenceManager();
8869	········this.mapping = pm.NDOMapping;
8870	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsTblGuidLeft" );
8871	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsTblGuidRightBase" );
8872	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsTblGuidRightDerived" );
8873	····}
8874	····[Test]
8875	····public void HasMappingTable()
8876	····{
8877	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
8878	····}
8879	····[Test]
8880	····public void HasTypeColumn()
8881	····{
8882	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
8883	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
8884	····}
8885	····[Test]
8886	····public void HasTypeCode()
8887	····{
8888	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
8889	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
8890	····}
8891	}
8892
8893
8894	[TestFixture]
8895	public class MappingTestAgrBi11OthpabsNoTblGuid
8896	{
8897	····PersistenceManager pm;
8898	····NDOMapping mapping;
8899	····Class ownClass;
8900	····Class otherClass;
8901	····Class otherDerivedClass;
8902	····[SetUp]
8903	····public void Setup()
8904	····{
8905	········this.pm = PmFactory.NewPersistenceManager();
8906	········this.mapping = pm.NDOMapping;
8907	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsNoTblGuidLeft" );
8908	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsNoTblGuidRightBase" );
8909	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsNoTblGuidRightDerived" );
8910	····}
8911	····[Test]
8912	····public void HasMappingTable()
8913	····{
8914	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
8915	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
8916	Assert. Null( otherDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #8") ;
8917	····}
8918	····[Test]
8919	····public void HasTypeColumn()
8920	····{
8921	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #9") ;
8922	····}
8923	····[Test]
8924	····public void HasTypeCode()
8925	····{
8926	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
8927	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
8928	····}
8929	}
8930
8931
8932	[TestFixture]
8933	public class MappingTestAgrBi11OthpabsTblGuid
8934	{
8935	····PersistenceManager pm;
8936	····NDOMapping mapping;
8937	····Class ownClass;
8938	····Class otherClass;
8939	····Class otherDerivedClass;
8940	····[SetUp]
8941	····public void Setup()
8942	····{
8943	········this.pm = PmFactory.NewPersistenceManager();
8944	········this.mapping = pm.NDOMapping;
8945	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsTblGuidLeft" );
8946	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsTblGuidRightBase" );
8947	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsTblGuidRightDerived" );
8948	····}
8949	····[Test]
8950	····public void HasMappingTable()
8951	····{
8952	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
8953	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
8954	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
8955	····}
8956	····[Test]
8957	····public void HasTypeColumn()
8958	····{
8959	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
8960	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
8961	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
8962	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
8963	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
8964	····}
8965	····[Test]
8966	····public void HasTypeCode()
8967	····{
8968	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
8969	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
8970	····}
8971	}
8972
8973
8974	[TestFixture]
8975	public class MappingTestAgrDirnOthpabsTblGuid
8976	{
8977	····PersistenceManager pm;
8978	····NDOMapping mapping;
8979	····Class ownClass;
8980	····Class otherClass;
8981	····Class otherDerivedClass;
8982	····[SetUp]
8983	····public void Setup()
8984	····{
8985	········this.pm = PmFactory.NewPersistenceManager();
8986	········this.mapping = pm.NDOMapping;
8987	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpabsTblGuidLeft" );
8988	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpabsTblGuidRightBase" );
8989	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpabsTblGuidRightDerived" );
8990	····}
8991	····[Test]
8992	····public void HasMappingTable()
8993	····{
8994	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
8995	····}
8996	····[Test]
8997	····public void HasTypeColumn()
8998	····{
8999	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
9000	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
9001	····}
9002	····[Test]
9003	····public void HasTypeCode()
9004	····{
9005	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9006	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9007	····}
9008	}
9009
9010
9011	[TestFixture]
9012	public class MappingTestAgrBin1OthpabsTblGuid
9013	{
9014	····PersistenceManager pm;
9015	····NDOMapping mapping;
9016	····Class ownClass;
9017	····Class otherClass;
9018	····Class otherDerivedClass;
9019	····[SetUp]
9020	····public void Setup()
9021	····{
9022	········this.pm = PmFactory.NewPersistenceManager();
9023	········this.mapping = pm.NDOMapping;
9024	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpabsTblGuidLeft" );
9025	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpabsTblGuidRightBase" );
9026	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpabsTblGuidRightDerived" );
9027	····}
9028	····[Test]
9029	····public void HasMappingTable()
9030	····{
9031	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
9032	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
9033	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
9034	····}
9035	····[Test]
9036	····public void HasTypeColumn()
9037	····{
9038	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
9039	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
9040	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
9041	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
9042	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
9043	····}
9044	····[Test]
9045	····public void HasTypeCode()
9046	····{
9047	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9048	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9049	····}
9050	}
9051
9052
9053	[TestFixture]
9054	public class MappingTestAgrBi1nOthpabsNoTblGuid
9055	{
9056	····PersistenceManager pm;
9057	····NDOMapping mapping;
9058	····Class ownClass;
9059	····Class otherClass;
9060	····Class otherDerivedClass;
9061	····[SetUp]
9062	····public void Setup()
9063	····{
9064	········this.pm = PmFactory.NewPersistenceManager();
9065	········this.mapping = pm.NDOMapping;
9066	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsNoTblGuidLeft" );
9067	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsNoTblGuidRightBase" );
9068	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsNoTblGuidRightDerived" );
9069	····}
9070	····[Test]
9071	····public void HasMappingTable()
9072	····{
9073	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
9074	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
9075	Assert. Null( otherDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #8") ;
9076	····}
9077	····[Test]
9078	····public void HasTypeColumn()
9079	····{
9080	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #9") ;
9081	····}
9082	····[Test]
9083	····public void HasTypeCode()
9084	····{
9085	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9086	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9087	····}
9088	}
9089
9090
9091	[TestFixture]
9092	public class MappingTestAgrBi1nOthpabsTblGuid
9093	{
9094	····PersistenceManager pm;
9095	····NDOMapping mapping;
9096	····Class ownClass;
9097	····Class otherClass;
9098	····Class otherDerivedClass;
9099	····[SetUp]
9100	····public void Setup()
9101	····{
9102	········this.pm = PmFactory.NewPersistenceManager();
9103	········this.mapping = pm.NDOMapping;
9104	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsTblGuidLeft" );
9105	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsTblGuidRightBase" );
9106	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsTblGuidRightDerived" );
9107	····}
9108	····[Test]
9109	····public void HasMappingTable()
9110	····{
9111	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
9112	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
9113	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
9114	····}
9115	····[Test]
9116	····public void HasTypeColumn()
9117	····{
9118	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
9119	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
9120	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
9121	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
9122	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
9123	····}
9124	····[Test]
9125	····public void HasTypeCode()
9126	····{
9127	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9128	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9129	····}
9130	}
9131
9132
9133	[TestFixture]
9134	public class MappingTestAgrBinnOthpabsTblGuid
9135	{
9136	····PersistenceManager pm;
9137	····NDOMapping mapping;
9138	····Class ownClass;
9139	····Class otherClass;
9140	····Class otherDerivedClass;
9141	····[SetUp]
9142	····public void Setup()
9143	····{
9144	········this.pm = PmFactory.NewPersistenceManager();
9145	········this.mapping = pm.NDOMapping;
9146	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpabsTblGuidLeft" );
9147	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpabsTblGuidRightBase" );
9148	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpabsTblGuidRightDerived" );
9149	····}
9150	····[Test]
9151	····public void HasMappingTable()
9152	····{
9153	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
9154	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
9155	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
9156	····}
9157	····[Test]
9158	····public void HasTypeColumn()
9159	····{
9160	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
9161	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
9162	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
9163	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
9164	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
9165	····}
9166	····[Test]
9167	····public void HasTypeCode()
9168	····{
9169	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9170	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9171	····}
9172	}
9173
9174
9175	[TestFixture]
9176	public class MappingTestCmpDir1OthpabsNoTblGuid
9177	{
9178	····PersistenceManager pm;
9179	····NDOMapping mapping;
9180	····Class ownClass;
9181	····Class otherClass;
9182	····Class otherDerivedClass;
9183	····[SetUp]
9184	····public void Setup()
9185	····{
9186	········this.pm = PmFactory.NewPersistenceManager();
9187	········this.mapping = pm.NDOMapping;
9188	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsNoTblGuidLeft" );
9189	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsNoTblGuidRightBase" );
9190	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsNoTblGuidRightDerived" );
9191	····}
9192	····[Test]
9193	····public void HasMappingTable()
9194	····{
9195	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
9196	····}
9197	····[Test]
9198	····public void HasTypeColumn()
9199	····{
9200	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #9") ;
9201	····}
9202	····[Test]
9203	····public void HasTypeCode()
9204	····{
9205	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9206	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9207	····}
9208	}
9209
9210
9211	[TestFixture]
9212	public class MappingTestCmpDir1OthpabsTblGuid
9213	{
9214	····PersistenceManager pm;
9215	····NDOMapping mapping;
9216	····Class ownClass;
9217	····Class otherClass;
9218	····Class otherDerivedClass;
9219	····[SetUp]
9220	····public void Setup()
9221	····{
9222	········this.pm = PmFactory.NewPersistenceManager();
9223	········this.mapping = pm.NDOMapping;
9224	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsTblGuidLeft" );
9225	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsTblGuidRightBase" );
9226	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsTblGuidRightDerived" );
9227	····}
9228	····[Test]
9229	····public void HasMappingTable()
9230	····{
9231	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
9232	····}
9233	····[Test]
9234	····public void HasTypeColumn()
9235	····{
9236	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
9237	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
9238	····}
9239	····[Test]
9240	····public void HasTypeCode()
9241	····{
9242	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9243	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9244	····}
9245	}
9246
9247
9248	[TestFixture]
9249	public class MappingTestCmpBi11OthpabsNoTblGuid
9250	{
9251	····PersistenceManager pm;
9252	····NDOMapping mapping;
9253	····Class ownClass;
9254	····Class otherClass;
9255	····Class otherDerivedClass;
9256	····[SetUp]
9257	····public void Setup()
9258	····{
9259	········this.pm = PmFactory.NewPersistenceManager();
9260	········this.mapping = pm.NDOMapping;
9261	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsNoTblGuidLeft" );
9262	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsNoTblGuidRightBase" );
9263	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsNoTblGuidRightDerived" );
9264	····}
9265	····[Test]
9266	····public void HasMappingTable()
9267	····{
9268	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
9269	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
9270	Assert. Null( otherDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #8") ;
9271	····}
9272	····[Test]
9273	····public void HasTypeColumn()
9274	····{
9275	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #9") ;
9276	····}
9277	····[Test]
9278	····public void HasTypeCode()
9279	····{
9280	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9281	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9282	····}
9283	}
9284
9285
9286	[TestFixture]
9287	public class MappingTestCmpBi11OthpabsTblGuid
9288	{
9289	····PersistenceManager pm;
9290	····NDOMapping mapping;
9291	····Class ownClass;
9292	····Class otherClass;
9293	····Class otherDerivedClass;
9294	····[SetUp]
9295	····public void Setup()
9296	····{
9297	········this.pm = PmFactory.NewPersistenceManager();
9298	········this.mapping = pm.NDOMapping;
9299	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsTblGuidLeft" );
9300	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsTblGuidRightBase" );
9301	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsTblGuidRightDerived" );
9302	····}
9303	····[Test]
9304	····public void HasMappingTable()
9305	····{
9306	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
9307	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
9308	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
9309	····}
9310	····[Test]
9311	····public void HasTypeColumn()
9312	····{
9313	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
9314	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
9315	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
9316	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
9317	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
9318	····}
9319	····[Test]
9320	····public void HasTypeCode()
9321	····{
9322	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9323	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9324	····}
9325	}
9326
9327
9328	[TestFixture]
9329	public class MappingTestCmpDirnOthpabsTblGuid
9330	{
9331	····PersistenceManager pm;
9332	····NDOMapping mapping;
9333	····Class ownClass;
9334	····Class otherClass;
9335	····Class otherDerivedClass;
9336	····[SetUp]
9337	····public void Setup()
9338	····{
9339	········this.pm = PmFactory.NewPersistenceManager();
9340	········this.mapping = pm.NDOMapping;
9341	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpabsTblGuidLeft" );
9342	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpabsTblGuidRightBase" );
9343	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpabsTblGuidRightDerived" );
9344	····}
9345	····[Test]
9346	····public void HasMappingTable()
9347	····{
9348	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
9349	····}
9350	····[Test]
9351	····public void HasTypeColumn()
9352	····{
9353	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
9354	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
9355	····}
9356	····[Test]
9357	····public void HasTypeCode()
9358	····{
9359	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9360	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9361	····}
9362	}
9363
9364
9365	[TestFixture]
9366	public class MappingTestCmpBin1OthpabsTblGuid
9367	{
9368	····PersistenceManager pm;
9369	····NDOMapping mapping;
9370	····Class ownClass;
9371	····Class otherClass;
9372	····Class otherDerivedClass;
9373	····[SetUp]
9374	····public void Setup()
9375	····{
9376	········this.pm = PmFactory.NewPersistenceManager();
9377	········this.mapping = pm.NDOMapping;
9378	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpabsTblGuidLeft" );
9379	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpabsTblGuidRightBase" );
9380	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpabsTblGuidRightDerived" );
9381	····}
9382	····[Test]
9383	····public void HasMappingTable()
9384	····{
9385	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
9386	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
9387	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
9388	····}
9389	····[Test]
9390	····public void HasTypeColumn()
9391	····{
9392	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
9393	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
9394	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
9395	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
9396	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
9397	····}
9398	····[Test]
9399	····public void HasTypeCode()
9400	····{
9401	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9402	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9403	····}
9404	}
9405
9406
9407	[TestFixture]
9408	public class MappingTestCmpBi1nOthpabsNoTblGuid
9409	{
9410	····PersistenceManager pm;
9411	····NDOMapping mapping;
9412	····Class ownClass;
9413	····Class otherClass;
9414	····Class otherDerivedClass;
9415	····[SetUp]
9416	····public void Setup()
9417	····{
9418	········this.pm = PmFactory.NewPersistenceManager();
9419	········this.mapping = pm.NDOMapping;
9420	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsNoTblGuidLeft" );
9421	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsNoTblGuidRightBase" );
9422	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsNoTblGuidRightDerived" );
9423	····}
9424	····[Test]
9425	····public void HasMappingTable()
9426	····{
9427	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
9428	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
9429	Assert. Null( otherDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #8") ;
9430	····}
9431	····[Test]
9432	····public void HasTypeColumn()
9433	····{
9434	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #9") ;
9435	····}
9436	····[Test]
9437	····public void HasTypeCode()
9438	····{
9439	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9440	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9441	····}
9442	}
9443
9444
9445	[TestFixture]
9446	public class MappingTestCmpBi1nOthpabsTblGuid
9447	{
9448	····PersistenceManager pm;
9449	····NDOMapping mapping;
9450	····Class ownClass;
9451	····Class otherClass;
9452	····Class otherDerivedClass;
9453	····[SetUp]
9454	····public void Setup()
9455	····{
9456	········this.pm = PmFactory.NewPersistenceManager();
9457	········this.mapping = pm.NDOMapping;
9458	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsTblGuidLeft" );
9459	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsTblGuidRightBase" );
9460	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsTblGuidRightDerived" );
9461	····}
9462	····[Test]
9463	····public void HasMappingTable()
9464	····{
9465	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
9466	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
9467	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
9468	····}
9469	····[Test]
9470	····public void HasTypeColumn()
9471	····{
9472	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
9473	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
9474	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
9475	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
9476	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
9477	····}
9478	····[Test]
9479	····public void HasTypeCode()
9480	····{
9481	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9482	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9483	····}
9484	}
9485
9486
9487	[TestFixture]
9488	public class MappingTestCmpBinnOthpabsTblGuid
9489	{
9490	····PersistenceManager pm;
9491	····NDOMapping mapping;
9492	····Class ownClass;
9493	····Class otherClass;
9494	····Class otherDerivedClass;
9495	····[SetUp]
9496	····public void Setup()
9497	····{
9498	········this.pm = PmFactory.NewPersistenceManager();
9499	········this.mapping = pm.NDOMapping;
9500	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpabsTblGuidLeft" );
9501	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpabsTblGuidRightBase" );
9502	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpabsTblGuidRightDerived" );
9503	····}
9504	····[Test]
9505	····public void HasMappingTable()
9506	····{
9507	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
9508	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
9509	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
9510	····}
9511	····[Test]
9512	····public void HasTypeColumn()
9513	····{